Some tweaks and fixes

src/formula/callable.hpp

@@ -24,20 +24,6 @@
 namespace wfl
 {
 
-enum FORMULA_ACCESS_TYPE { FORMULA_READ_ONLY, FORMULA_WRITE_ONLY, FORMULA_READ_WRITE };
-
-struct formula_input
-{
-	explicit formula_input(const std::string& name, FORMULA_ACCESS_TYPE access = FORMULA_READ_WRITE)
-		: name(name), access(access)
-	{}
-
-	std::string name;
-	FORMULA_ACCESS_TYPE access;
-};
-
-using formula_input_vector = std::vector<formula_input>;
-
 // Interface for objects that can have formulae run on them
 class formula_callable
 {

src/formula/callable_fwd.hpp

@@ -23,6 +23,17 @@ namespace wfl
 class formula_callable;
 class formula_debugger;
 
+enum FORMULA_ACCESS_TYPE { FORMULA_READ_ONLY, FORMULA_WRITE_ONLY, FORMULA_READ_WRITE };
+
+struct formula_input {
+	explicit formula_input(const std::string& name, FORMULA_ACCESS_TYPE access = FORMULA_READ_WRITE)
+		: name(name), access(access) {}
+
+	std::string name;
+	FORMULA_ACCESS_TYPE access;
+};
+
+using formula_input_vector = std::vector<formula_input>;
 using formula_callable_ptr       = std::shared_ptr<formula_callable>;
 using const_formula_callable_ptr = std::shared_ptr<const formula_callable>;
 using formula_seen_stack = std::vector<const formula_callable*>;

src/formula/variant.cpp

@@ -119,14 +119,14 @@ variant_iterator variant_iterator::operator++(int)
 
 variant_iterator& variant_iterator::operator--()
 {
-	container_->iterator_inc(iter_);
+	container_->iterator_dec(iter_);
 	return *this;
 }
 
 variant_iterator variant_iterator::operator--(int)
 {
 	variant_iterator temp(*this);
-	container_->iterator_inc(iter_);
+	container_->iterator_dec(iter_);
 	return temp;
 }
 

src/formula/variant_value.cpp

@@ -147,35 +147,30 @@ boost::iterator_range<variant_iterator> variant_callable::make_iterator() const
 		return variant_value_base::make_iterator();
 	}
 
-	std::shared_ptr<formula_input_vector> inputs;
-	inputs.reset(new formula_input_vector(callable_->inputs()));
+	if(inputs.empty()) {
+		callable_->get_inputs(inputs);
+	}
 
-	return {variant_iterator(this, std::make_pair(inputs, inputs->cbegin())), variant_iterator(this, std::make_pair(inputs, inputs->cend()))};
+	return {variant_iterator(this, inputs.cbegin()), variant_iterator(this, inputs.cend())};
 }
 
-using callable_iter = std::pair<std::shared_ptr<formula_input_vector>, formula_input_vector::const_iterator>;
-
 variant variant_callable::deref_iterator(const boost::any& iter) const
 {
 	if(!callable_) {
 		return variant();
 	}
 
-	return callable_->query_value(boost::any_cast<callable_iter>(iter).second->name);
+	return callable_->query_value(boost::any_cast<const formula_input_vector::const_iterator&>(iter)->name);
 }
 
-boost::any variant_callable::iterator_inc(const boost::any& iter) const
+void variant_callable::iterator_inc(boost::any& iter) const
 {
-	callable_iter new_iter = boost::any_cast<callable_iter>(iter);
-	++new_iter.second;
-	return new_iter;
+	++boost::any_cast<formula_input_vector::const_iterator&>(iter);
 }
 
-boost::any variant_callable::iterator_dec(const boost::any& iter) const
+void variant_callable::iterator_dec(boost::any& iter) const
 {
-	callable_iter new_iter = boost::any_cast<callable_iter>(iter);
-	--new_iter.second;
-	return new_iter;
+	--boost::any_cast<formula_input_vector::const_iterator&>(iter);
 }
 
 std::string variant_string::get_serialized_string() const
@@ -257,19 +252,26 @@ std::string variant_container<T>::get_debug_string(formula_seen_stack& seen, boo
 }
 
 template<typename T>
-boost::any variant_container<T>::iterator_inc(const boost::any& iter) const
+void variant_container<T>::iterator_inc(boost::any& iter) const
 {
-	typename T::const_iterator new_iter = boost::any_cast<typename T::const_iterator>(iter);
-	++new_iter;
-	return new_iter;
+	++boost::any_cast<typename T::const_iterator&>(iter);
 }
 
 template<typename T>
-boost::any variant_container<T>::iterator_dec(const boost::any& iter) const
+void variant_container<T>::iterator_dec(boost::any& iter) const
 {
-	typename T::const_iterator new_iter = boost::any_cast<typename T::const_iterator>(iter);
-	--new_iter;
-	return new_iter;
+	--boost::any_cast<typename T::const_iterator&>(iter);
+}
+
+template<typename T>
+boost::iterator_range<variant_iterator> variant_container<T>::make_iterator() const
+{
+	return {variant_iterator(this, get_container().cbegin()), variant_iterator(this, get_container().cend())};
+}
+
+template<typename T>
+bool variant_container<T>::iterator_equals(const boost::any& first, const boost::any& second) const {
+	return boost::any_cast<typename T::const_iterator>(first) == boost::any_cast<typename T::const_iterator>(second);
 }
 
 // Force compilation of the following template instantiations
@@ -326,14 +328,9 @@ bool variant_list::less_than(variant_value_base& other) const
 	return num_elements() < other.num_elements();
 }
 
-boost::iterator_range<variant_iterator> variant_list::make_iterator() const
-{
-	return {variant_iterator(this, get_container().cbegin()), variant_iterator(this, get_container().cend())};
-}
-
 variant variant_list::deref_iterator(const boost::any& iter) const
 {
-	return *boost::any_cast<variant_vector::const_iterator>(iter);
+	return *boost::any_cast<const variant_vector::const_iterator&>(iter);
 }
 
 std::string variant_map::to_string_detail(const variant_map_raw::value_type& container_val, mod_func_t mod_func) const
@@ -357,14 +354,9 @@ bool variant_map::less_than(variant_value_base& other) const
 	return get_container() < value_ref_cast<variant_map>(other).get_container();
 }
 
-boost::iterator_range<variant_iterator> variant_map::make_iterator() const
-{
-	return {variant_iterator(this, get_container().cbegin()), variant_iterator(this, get_container().cend())};
-}
-
 variant variant_map::deref_iterator(const boost::any& iter) const
 {
-	const variant_map_raw::value_type& p = *boost::any_cast<variant_map_raw::const_iterator>(iter);
+	const variant_map_raw::value_type& p = *boost::any_cast<const variant_map_raw::const_iterator&>(iter);
 	key_value_pair* the_pair = new key_value_pair(p.first, p.second);
 	return variant(the_pair);
 }

src/formula/variant_value.hpp

@@ -31,7 +31,6 @@
 
 namespace wfl
 {
-class formula_callable;
 class variant_value_base;
 class variant_iterator;
 class variant;
@@ -153,17 +152,44 @@ class variant_value_base
 	}
 
 	/**
-	 * Iterator interface.
+	 * Creates an iterator pair that can be used for iteration.
+	 * For an iterable type, it should use the two-argument constructor of variant-iterator,
+	 * passing the underlying iterator as the boost::any parameter.
 	 *
-	 * These implement functionality used by @ref variant_iterator to operator on
-	 * iterators of the given value type - hence the use of boost::any here.
+	 * This creates both the begin and end iterator, but the variant implementation
+	 * discards one of the two.
 	 */
 	virtual boost::iterator_range<variant_iterator> make_iterator() const;
+	/**
+	 * Implements the dereference functionality of @ref variant_iterator
+	 * for a value of this type.
+	 *
+	 * @param iter The opaque reference that was passed to the variant_iterator by @ref make_iterator.
+	 */
 	virtual variant deref_iterator(const boost::any& iter) const;
-
-	virtual boost::any iterator_inc(const boost::any& iter) const { return iter; }
-	virtual boost::any iterator_dec(const boost::any& iter) const { return iter; }
-
+	/**
+	 * Implements the increment functionality of @ref variant_iterator
+	 * for a value of this type.
+	 *
+	 * @param iter The opaque reference that was passed to the variant_iterator by @ref make_iterator.
+	 */
+	virtual void iterator_inc(boost::any&) const {}
+	/**
+	 * Implements the decrement functionality of @ref variant_iterator
+	 * for a value of this type.
+	 *
+	 * @param iter The opaque reference that was passed to the variant_iterator by @ref make_iterator.
+	 */
+	virtual void iterator_dec(boost::any&) const {}
+	/**
+	 * Implements the equality functionality of @ref variant_iterator
+	 * for a value of this type.
+	 *
+	 * Note that this is only called if the two iterators are already known to be of the same type.
+	 *
+	 * @param first The opaque reference that was passed to the variant_iterator by @ref make_iterator.
+	 * @param second The opaque reference that was passed to the variant_iterator by @ref make_iterator.
+	 */
 	virtual bool iterator_equals(const boost::any& /*first*/, const boost::any& /*second*/) const
 	{
 		return true;
@@ -320,8 +346,8 @@ class variant_callable : public variant_value_base
 	virtual boost::iterator_range<variant_iterator> make_iterator() const override;
 	virtual variant deref_iterator(const boost::any& iter) const override;
 
-	virtual boost::any iterator_inc(const boost::any& iter) const override;
-	virtual boost::any iterator_dec(const boost::any& iter) const override;
+	virtual void iterator_inc(boost::any& iter) const override;
+	virtual void iterator_dec(boost::any& iter) const override;
 
 	virtual bool iterator_equals(const boost::any& /*first*/, const boost::any& /*second*/) const
 	{
@@ -330,6 +356,7 @@ class variant_callable : public variant_value_base
 
 private:
 	const formula_callable* callable_;
+	mutable formula_input_vector inputs; // for iteration
 };
 
 
@@ -440,14 +467,11 @@ class variant_container : public variant_value_base
 	}
 
 	// We implement these in the here since the interface is the same for all
-	// specializations and leave the other functions to the derived classes.
-	virtual boost::any iterator_inc(const boost::any&) const override;
-	virtual boost::any iterator_dec(const boost::any&) const override;
-
-	virtual bool iterator_equals(const boost::any& first, const boost::any& second) const override
-	{
-		return boost::any_cast<typename T::const_iterator>(first) == boost::any_cast<typename T::const_iterator>(second);
-	}
+	// specializations and leave the deref function to the derived classes.
+	virtual boost::iterator_range<variant_iterator> make_iterator() const override;
+	virtual void iterator_inc(boost::any&) const override;
+	virtual void iterator_dec(boost::any&) const override;
+	virtual bool iterator_equals(const boost::any& first, const boost::any& second) const override;
 
 protected:
 	using mod_func_t = std::function<std::string(const variant&)>;
@@ -488,7 +512,6 @@ class variant_list : public variant_container<variant_vector>
 		return type;
 	}
 
-	virtual boost::iterator_range<variant_iterator> make_iterator() const override;
 	virtual variant deref_iterator(const boost::any&) const override;
 
 private:
@@ -515,7 +538,6 @@ class variant_map : public variant_container<variant_map_raw>
 		return type;
 	}
 
-	virtual boost::iterator_range<variant_iterator> make_iterator() const;
 	virtual variant deref_iterator(const boost::any&) const;
 
 private: