comparison DEPENDENCIES/generic/include/boost/spirit/home/karma/detail/pass_container.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

       : pass_through_container_optional<
             Container, ValueType, Attribute, Sequence>
     {};
 
     // If both, the containers value type and the exposed attribute type are
-    // optionals we are allowed to pass through the the container only if the
+    // optionals we are allowed to pass through the container only if the
     // embedded types of those optionals are not compatible.
     template <typename Container, typename ValueType, typename Attribute
       , typename Sequence>
     struct pass_through_container<
             Container, boost::optional<ValueType>, boost::optional<Attribute>

     // Specialization for exposed variant attributes
     //
     // We pass through the container attribute if at least one of the embedded
     // types in the variant requires to pass through the attribute
 
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+    template <typename Container, typename ValueType, typename Sequence
+      , typename T>
+    struct pass_through_container<Container, ValueType, boost::variant<T>
+          , Sequence>
+      : pass_through_container<Container, ValueType, T, Sequence>
+    {};
+
+    template <typename Container, typename ValueType, typename Sequence
+      , typename T0, typename ...TN>
+    struct pass_through_container<Container, ValueType
+          , boost::variant<T0, TN...>, Sequence>
+      : mpl::bool_<pass_through_container<
+            Container, ValueType, T0, Sequence
+            >::type::value || pass_through_container<
+                Container, ValueType, boost::variant<TN...>, Sequence
+            >::type::value>
+    {};
+#else
 #define BOOST_SPIRIT_PASS_THROUGH_CONTAINER(z, N, _)                          \
     pass_through_container<Container, ValueType,                              \
         BOOST_PP_CAT(T, N), Sequence>::type::value ||                         \
     /***/
 

       : mpl::bool_<BOOST_PP_REPEAT(BOOST_VARIANT_LIMIT_TYPES
           , BOOST_SPIRIT_PASS_THROUGH_CONTAINER, _) false>
     {};
 
 #undef BOOST_SPIRIT_PASS_THROUGH_CONTAINER
+#endif
 }}}}
 
 ///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace spirit { namespace traits
 {

     {};
 }}}
 
 namespace boost { namespace spirit { namespace karma { namespace detail
 {
+    template <typename Iterator>
+    struct pass_container_base
+    {
+        pass_container_base(Iterator begin, Iterator end)
+          : iter(begin), end(end)
+        {}
+
+        mutable Iterator iter;
+        mutable Iterator end;
+    };
+
+    template <typename Iterator>
+    struct pass_container_base<Iterator&>
+    {
+        pass_container_base(Iterator& begin, Iterator& end)
+          : iter(begin), end(end)
+        {}
+
+        Iterator& iter;
+        Iterator& end;
+    };
+
     ///////////////////////////////////////////////////////////////////////////
     // This function handles the case where the attribute (Attr) given
     // to the sequence is an STL container. This is a wrapper around F.
     // The function F does the actual generating.
     template <typename F, typename Attr, typename Iterator, typename Sequence>
-    struct pass_container
-    {
+    struct pass_container : pass_container_base<Iterator>
+    {
+        typedef pass_container_base<Iterator> base_type;
         typedef typename F::context_type context_type;
 
         pass_container(F const& f, Iterator begin, Iterator end)
-          : f(f), iter(begin), end(end)
+          : base_type(begin, end)
+          , f(f)
         {}
 
         bool is_at_end() const
         {
-            return traits::compare(iter, end);
+            return traits::compare(this->iter, this->end);
         }
 
         void next()
         {
-            traits::next(iter);
+            traits::next(this->iter);
         }
 
         // this is for the case when the current element expects an attribute
         // which is taken from the next entry in the container
         template <typename Component>
         bool dispatch_container(Component const& component, mpl::false_) const
         {
             // get the next value to generate from container
-            if (!is_at_end() && !f(component, traits::deref(iter)))
+            if (!is_at_end() && !f(component, traits::deref(this->iter)))
             {
                 // needs to return false as long as everything is ok
-                traits::next(iter);
+                traits::next(this->iter);
                 return false;
             }
 
             // either no elements available any more or generation failed
             return true;

         // attribute which is a container itself, this element will push its
         // data directly into the attribute container
         template <typename Component>
         bool dispatch_container(Component const& component, mpl::true_) const
         {
-            return f(component, make_iterator_range(iter, end));
+            return f(component, make_iterator_range(this->iter, this->end));
         }
 
         ///////////////////////////////////////////////////////////////////////
         // this is for the case when the current element doesn't expect an
         // attribute

 
             return dispatch_attribute(component, predicate());
         }
 
         F f;
-        mutable Iterator iter;
-        mutable Iterator end;
 
     private:
         // silence MSVC warning C4512: assignment operator could not be generated
         pass_container& operator= (pass_container const&);
     };