Create branches/filesystem-v3 for v2 removal

[SVN r77385]

doc/adapted.qbk

@@ -244,7 +244,7 @@ __random_access_sequence__.
 
 [heading Semantics]
 
-The above macro generates the necessary code to adapt `struct_name` or an 
+The above macro generates the necessary code to adapt `struct_name` or an
 arbitrary specialization of `struct_name` as a model of
 __random_access_sequence__.
 The sequence `(template_param0)(template_param1)...` declares the names of
@@ -287,9 +287,9 @@ namespace qualified name of the struct to be adapted.
 [section:adapt_struct_named BOOST_FUSION_ADAPT_STRUCT_NAMED]
 
 [heading Description]
-BOOST_FUSION_ADAPT_STRUCT_NAMED and BOOST_FUSION_ADAPT_STRUCT_NAMED_NS are 
-macros that can be used to generate all the necessary boilerplate to make an 
-arbitrary struct a model of __random_access_sequence__. The given struct is 
+BOOST_FUSION_ADAPT_STRUCT_NAMED and BOOST_FUSION_ADAPT_STRUCT_NAMED_NS are
+macros that can be used to generate all the necessary boilerplate to make an
+arbitrary struct a model of __random_access_sequence__. The given struct is
 adapted using the given name.
 
 [heading Synopsis]
@@ -312,7 +312,7 @@ adapted using the given name.
 [heading Semantics]
 
 The above macros generate the necessary code to adapt `struct_name`
-as a model of __random_access_sequence__ while using `adapted_name` as the 
+as a model of __random_access_sequence__ while using `adapted_name` as the
 name of the adapted struct.
 The sequence `(namespace0)(namespace1)...` declares the namespace
 for `adapted_name`. It yields to a fully qualified name for `adapted_name` of
@@ -427,7 +427,7 @@ __random_access_sequence__ and __associative_sequence__.
 
 [heading Semantics]
 
-The above macro generates the necessary code to adapt `struct_name` or an 
+The above macro generates the necessary code to adapt `struct_name` or an
 arbitrary specialization of `struct_name` as a model of
 __random_access_sequence__ and __associative_sequence__.
 The sequence `(template_param0)(template_param1)...` declares the names of
@@ -463,7 +463,7 @@ namespace qualified name of the struct to be adapted.
         struct name;
         struct age;
     }
-    
+
     // Any instantiated demo::employee is now a Fusion sequence.
     // It is also an associative sequence with
     // keys keys::name and keys::age present.
@@ -478,8 +478,8 @@ namespace qualified name of the struct to be adapted.
 [section:adapt_assoc_struct_named BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED]
 
 [heading Description]
-BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED and BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS are 
-macros that can be used to generate all the necessary boilerplate to make an 
+BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED and BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED_NS are
+macros that can be used to generate all the necessary boilerplate to make an
 arbitrary struct a model of __random_access_sequence__ and
 __associative_sequence__. The given struct is adapted using the given name.
 
@@ -539,7 +539,7 @@ namespace qualified name of the struct to be converted.
         struct name;
         struct age;
     }
-    
+
     // boost::fusion::adapted::adapted_employee is now a Fusion sequence
     // referring to demo::employee
     BOOST_FUSION_ADAPT_ASSOC_STRUCT_NAMED(
@@ -567,7 +567,7 @@ __random_access_sequence__.
 [heading Expression Semantics]
 
 The above macro generates the necessary code to adapt `type_name`
-as a model of __random_access_sequence__. 
+as a model of __random_access_sequence__.
 The sequence of
 [^(attribute_type['N], attribute_const_type['N], get_expr['N], set_expr['N])]
 quadruples declares the types, const types, get-expressions and set-expressions
@@ -600,7 +600,7 @@ namespace qualified name of the class type to be adapted.
 
     #include <boost/fusion/adapted/adt/adapt_adt.hpp>
     #include <boost/fusion/include/adapt_adt.hpp>
-    
+
 [heading Example]
     namespace demo
     {
@@ -609,41 +609,41 @@ namespace qualified name of the class type to be adapted.
         private:
             std::string name;
             int age;
-                
+
         public:
             void set_name(std::string const& n)
             {
                 name=n;
             }
-                
+
             void set_age(int a)
             {
                 age=a;
             }
-                
+
             std::string const& get_name()const
             {
                 return name;
             }
-                
+
             int get_age()const
             {
                 return age;
             }
         };
     }
-    
+
     BOOST_FUSION_ADAPT_ADT(
         demo::employee,
         (std::string const&, std::string const&, obj.get_name(), obj.set_name(val))
         (int, int, obj.get_age(), obj.set_age(val)))
-    
+
     demo::employee e;
     front(e)="Edward Norton";
     back(e)=41;
     //Prints 'Edward Norton is 41 years old'
     std::cout << e.get_name() << " is " << e.get_age() << " years old" << std::endl;
-    
+
 [heading See also]
 
 __adt_attribute_proxy__
@@ -658,7 +658,7 @@ __random_access_sequence__.
 
 [heading Synopsis]
 
-    BOOST_FUSION_ADAPT_TPL_ADT(
+    BOOST_FUSION_ADAPT_ADT(
         (template_param0)(template_param1)...,
         (type_name) (specialization_param0)(specialization_param1)...,
         (attribute_type0, attribute_const_type0, get_expr0, set_expr0)
@@ -670,7 +670,7 @@ __random_access_sequence__.
 
 The above macro generates the necessary code to adapt `type_name`
 or an arbitrary specialization of `type_name`
-as a model of __random_access_sequence__. 
+as a model of __random_access_sequence__.
 The sequence `(template_param0)(template_param1)...` declares the names of
 the template type parameters used.
 The sequence `(specialization_param0)(specialization_param1)...`
@@ -708,40 +708,40 @@ namespace qualified name of the template class type to be adapted.
 
     #include <boost/fusion/adapted/adt/adapt_adt.hpp>
     #include <boost/fusion/include/adapt_adt.hpp>
-    
+
 [heading Example]
     namespace demo
-    { 
+    {
 		template<typename Name, typename Age>
         struct employee
         {
         private:
             Name name;
             Age age;
-                
+
         public:
             void set_name(Name const& n)
             {
                 name=n;
             }
-                
+
             void set_age(Age const& a)
             {
                 age=a;
             }
-                
+
             Name const& get_name()const
             {
                 return name;
             }
-                
+
             Age const& get_age()const
             {
                 return age;
             }
         };
     }
-    
+
     BOOST_FUSION_ADAPT_TPL_ADT(
         (Name)(Age),
         (demo::employee) (Name)(Age),
@@ -753,7 +753,7 @@ namespace qualified name of the template class type to be adapted.
     boost::fusion::back(e)=41;
     //Prints 'Edward Norton is 41 years old'
     std::cout << e.get_name() << " is " << e.get_age() << " years old" << std::endl;
-    
+
 [heading See also]
 
 __adt_attribute_proxy__
@@ -778,7 +778,7 @@ __random_access_sequence__  and __associative_sequence__.
 [heading Expression Semantics]
 
 The above macro generates the necessary code to adapt `type_name`
-as a model of __random_access_sequence__ and __associative_sequence__. 
+as a model of __random_access_sequence__ and __associative_sequence__.
 The sequence of
 [^(attribute_type['N], attribute_const_type['N], get_expr['N], set_expr['N], key_type['N])]
 5-tuples declares the types, const types, get-expressions, set-expressions and key types
@@ -800,7 +800,7 @@ The actual return type of fusion's intrinsic sequence access (meta-)functions
 when in invoked with (an instance of) `type_name` is a proxy type.
 This type is implicitly convertible to the attribute type via [^get_expr['N]] and
 forwards assignment to the underlying element via [^set_expr['N]].
-The value type (that is the type returned by __result_of_value_of__, __result_of_value_of_data__, 
+The value type (that is the type returned by __result_of_value_of__, __result_of_value_of_data__,
 __result_of_value_at__, __result_of_value_at_c__ and __result_of_value_at_key__) of the ['N]th element
 is [^attribute_type['N]] with const-qualifier and reference removed.
 
@@ -811,7 +811,7 @@ namespace qualified name of the class type to be adapted.
 
     #include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
     #include <boost/fusion/include/adapt_assoc_adt.hpp>
-    
+
 [heading Example]
     namespace demo
     {
@@ -820,47 +820,47 @@ namespace qualified name of the class type to be adapted.
         private:
             std::string name;
             int age;
-                
+
         public:
             void set_name(std::string const& n)
             {
                 name=n;
             }
-                
+
             void set_age(int a)
             {
                 age=a;
             }
-                
+
             std::string const& get_name()const
             {
                 return name;
             }
-                
+
             int get_age()const
             {
                 return age;
             }
         };
     }
-    
+
     namespace keys
     {
         struct name;
         struct age;
     }
-    
+
     BOOST_FUSION_ADAPT_ASSOC_ADT(
         demo::employee,
         (std::string const&, std::string const&, obj.get_name(), obj.set_name(val), keys::name)
         (int, int, obj.get_age(), obj.set_age(val), keys::age))
-    
+
     demo::employee e;
     at_key<keys::name>(e)="Edward Norton";
     at_key<keys::age>(e)=41;
     //Prints 'Edward Norton is 41 years old'
     std::cout << e.get_name() << " is " << e.get_age() << " years old" << std::endl;
-    
+
 [heading See also]
 
 __adt_attribute_proxy__
@@ -887,7 +887,7 @@ __random_access_sequence__  and __associative_sequence__.
 
 The above macro generates the necessary code to adapt `type_name`
 or an arbitrary specialization of `type_name`
-as a model of __random_access_sequence__ and __associative_sequence__. 
+as a model of __random_access_sequence__ and __associative_sequence__.
 The sequence `(template_param0)(template_param1)...` declares the names of
 the template type parameters used.
 The sequence `(specialization_param0)(specialization_param1)...`
@@ -914,7 +914,7 @@ The actual return type of fusion's intrinsic sequence access (meta-)functions
 when in invoked with (an instance of) `type_name` is a proxy type.
 This type is implicitly convertible to the attribute type via [^get_expr['N]] and
 forwards assignment to the underlying element via [^set_expr['N]].
-The value type (that is the type returned by __result_of_value_of__, __result_of_value_of_data__, 
+The value type (that is the type returned by __result_of_value_of__, __result_of_value_of_data__,
 __result_of_value_at__, __result_of_value_at_c__ and __result_of_value_at_key__) of the ['N]th element
 is [^attribute_type['N]] with const-qualifier and reference removed.
 
@@ -925,7 +925,7 @@ namespace qualified name of the template class type to be adapted.
 
     #include <boost/fusion/adapted/adt/adapt_assoc_adt.hpp>
     #include <boost/fusion/include/adapt_assoc_adt.hpp>
-    
+
 [heading Example]
     namespace demo
     {
@@ -935,48 +935,48 @@ namespace qualified name of the template class type to be adapted.
         private:
             Name name;
             Age age;
-                
+
         public:
             void set_name(Name const& n)
             {
                 name=n;
             }
-                
+
             void set_age(Age const& a)
             {
                 age=a;
             }
-                
+
             Name const& get_name()const
             {
                 return name;
             }
-                
+
             Age const& get_age()const
             {
                 return age;
             }
         };
     }
-    
+
     namespace keys
     {
         struct name;
         struct age;
     }
-    
+
     BOOST_FUSION_ADAPT_ASSOC_TPL_ADT(
         (Name)(Age),
         (demo::employee) (Name)(Age),
         (Name const&, Name const&, obj.get_name(), obj.set_name(val), keys::name)
         (Age const&, Age const&, obj.get_age(), obj.set_age(val), keys::age))
-    
+
     demo::employee<std::string, int> e;
     at_key<keys::name>(e)="Edward Norton";
     at_key<keys::age>(e)=41;
     //Prints 'Edward Norton is 41 years old'
     std::cout << e.get_name() << " is " << e.get_age() << " years old" << std::endl;
-    
+
 [heading See also]
 
 __adt_attribute_proxy__
@@ -1028,14 +1028,14 @@ defined in __random_access_sequence__.
     [[`struct_name(e0, e1,... en)`]   [Creates an instance of `struct_name` with elements `e0`...`en`.]]
     [[`struct_name(fs)`]              [Copy constructs an instance of `struct_name` from a __forward_sequence__ `fs`.]]
     [[`str = fs`]                     [Assigns from a __forward_sequence__ `fs`.]]
-    [[`str.member_nameN`]             [Access of struct member `member_nameN`]] 
+    [[`str.member_nameN`]             [Access of struct member `member_nameN`]]
 ]
 
 [heading Header]
 
     #include <boost/fusion/adapted/struct/define_struct.hpp>
     #include <boost/fusion/include/define_struct.hpp>
-    
+
 [heading Example]
 
     // demo::employee is a Fusion sequence
@@ -1097,14 +1097,14 @@ defined in __random_access_sequence__.
     [[`Str(e0, e1,... en)`]           [Creates an instance of `Str` with elements `e0`...`en`.]]
     [[`Str(fs)`]                      [Copy constructs an instance of `Str` from a __forward_sequence__ `fs`.]]
     [[`str = fs`]                     [Assigns from a __forward_sequence__ `fs`.]]
-    [[`str.member_nameN`]             [Access of struct member `member_nameN`]] 
+    [[`str.member_nameN`]             [Access of struct member `member_nameN`]]
 ]
 
 [heading Header]
 
     #include <boost/fusion/adapted/struct/define_struct.hpp>
     #include <boost/fusion/include/define_struct.hpp>
-    
+
 [heading Example]
 
     // Any instantiated demo::employee is a Fusion sequence
@@ -1115,100 +1115,6 @@ defined in __random_access_sequence__.
 
 [endsect]
 
-[section:define_struct_inline BOOST_FUSION_DEFINE_STRUCT_INLINE]
-
-[heading Description]
-
-BOOST_FUSION_DEFINE_STRUCT_INLINE is a macro that can be used to generate all
-the necessary boilerplate to define and adapt an arbitrary struct as a model of
-__random_access_sequence__. Unlike BOOST_FUSION_DEFINE_STRUCT, it can be used
-at class or namespace scope.
-
-[heading Synopsis]
-
-    BOOST_FUSION_DEFINE_STRUCT_INLINE(
-        struct_name,
-        (member_type0, member_name0)
-        (member_type1, member_name1)
-        ...
-        )
-
-[heading Expression Semantics]
-
-The semantics of BOOST_FUSION_DEFINE_STRUCT_INLINE are identical to those of
-BOOST_FUSION_DEFINE_STRUCT, with two differences:
-
-# BOOST_FUSION_DEFINE_STRUCT_INLINE can be used at class or namespace scope, and
-  thus does not take a namespace list parameter.
-# The structure generated by BOOST_FUSION_DEFINE_STRUCT_INLINE has a base class,
-  and is thus not POD in C++03.
-
-[heading Header]
-
-    #include <boost/fusion/adapted/struct/define_struct_inline.hpp>
-    #include <boost/fusion/include/define_struct_inline.hpp>
-
-[heading Example]
-
-    // enclosing::employee is a Fusion sequence
-    class enclosing
-    {
-        BOOST_FUSION_DEFINE_STRUCT_INLINE(
-            employee,
-            (std::string, name)
-            (int, age))
-    };
-
-
-[endsect]
-
-[section:define_tpl_struct_inline BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE]
-
-[heading Description]
-
-BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE is a macro that can be used to generate 
-all the necessary boilerplate to define and adapt an arbitrary template struct 
-as a model of __random_access_sequence__. Unlike BOOST_FUSION_DEFINE_TPL_STRUCT,
-it can be used at class or namespace scope.
-
-[heading Synopsis]
-
-    BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE(
-        (template_param0)(template_param1)...,
-        struct_name,
-        (member_type0, member_name0)
-        (member_type1, member_name1)
-        ...
-        )
-
-[heading Expression Semantics]
-
-The semantics of BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE are identical to those of
-BOOST_FUSION_DEFINE_TPL_STRUCT, with two differences:
-
-# BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE can be used at class or namespace scope,
-  and thus does not take a namespace list parameter.
-# The structure generated by BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE has a base
-  class, and is thus not POD in C++03.
-
-[heading Header]
-
-    #include <boost/fusion/adapted/struct/define_struct_inline.hpp>
-    #include <boost/fusion/include/define_struct_inline.hpp>
-
-[heading Example]
-
-    // Any instantiated enclosing::employee is a Fusion sequence
-    class enclosing
-    {
-        BOOST_FUSION_DEFINE_TPL_STRUCT(
-            (Name)(Age), employee,
-            (Name, name)
-            (Age, age))
-    };
-
-[endsect]
-
 [section:define_assoc_struct BOOST_FUSION_DEFINE_ASSOC_STRUCT]
 
 [heading Description]
@@ -1256,14 +1162,14 @@ defined in __random_access_sequence__ and __associative_sequence__.
     [[`struct_name(e0, e1,... en)`]   [Creates an instance of `struct_name` with elements `e0`...`en`.]]
     [[`struct_name(fs)`]              [Copy constructs an instance of `struct_name` from a __forward_sequence__ `fs`.]]
     [[`str = fs`]                     [Assigns from a __forward_sequence__ `fs`.]]
-    [[`str.member_nameN`]             [Access of struct member `member_nameN`]] 
+    [[`str.member_nameN`]             [Access of struct member `member_nameN`]]
 ]
 
 [heading Header]
 
     #include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
     #include <boost/fusion/include/define_assoc_struct.hpp>
-    
+
 [heading Example]
 
     namespace keys
@@ -1271,7 +1177,7 @@ defined in __random_access_sequence__ and __associative_sequence__.
         struct name;
         struct age;
     }
-    
+
     // demo::employee is a Fusion sequence
     BOOST_FUSION_DEFINE_ASSOC_STRUCT(
         (demo), employee,
@@ -1332,14 +1238,14 @@ defined in __random_access_sequence__ and __associative_sequence__.
     [[`Str(e0, e1,... en)`]           [Creates an instance of `Str` with elements `e0`...`en`.]]
     [[`Str(fs)`]                      [Copy constructs an instance of `Str` from a __forward_sequence__ `fs`.]]
     [[`str = fs`]                     [Assigns from a __forward_sequence__ `fs`.]]
-    [[`str.member_nameN`]             [Access of struct member `member_nameN`]] 
+    [[`str.member_nameN`]             [Access of struct member `member_nameN`]]
 ]
 
 [heading Header]
 
     #include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
     #include <boost/fusion/include/define_assoc_struct.hpp>
-    
+
 [heading Example]
 
     namespace keys
@@ -1347,7 +1253,7 @@ defined in __random_access_sequence__ and __associative_sequence__.
         struct name;
         struct age;
     }
-    
+
     // Any instantiated demo::employee is a Fusion sequence
     BOOST_FUSION_DEFINE_ASSOC_TPL_STRUCT(
         (Name)(Age), (demo), employee,

doc/algorithm.qbk

@@ -134,7 +134,7 @@ the first call) and [arg_desc] of `seq`.
         >
     typename result_of_name_macro<Sequence, State const, F>::type name_macro(
         Sequence& seq, State const& initial_state, F f);
-        
+
     template<
         typename Sequence,
         typename State,

doc/changelog.qbk

@@ -44,5 +44,6 @@ This section summarizes significant changes to the Fusion library.
 * September 16, 2011: Added preprocessed files (using wave) to speed up
   compilation (Joel de Guzman)
 * October 8, 2011: Added adaptor for std::tuple (Joel de Guzman)
+* October 10, 2011: Made map random access (Brandon Kohn)
 
 [endsect]

doc/container.qbk

@@ -21,11 +21,10 @@ __views__. These containers are more or less counterparts of those in __stl__.
 
 [heading Description]
 
-`vector` is a __random_access_sequence__ of heterogenous typed data
-structured as a simple `struct` where each element is held as a member
-variable. `vector` is the simplest of the Fusion sequence container (a
-vector with N elements is just a struct with N members), and in many
-cases the most efficient.
+`vector` is a __random_access_sequence__ of heterogenous typed
+data structured as a simple `struct` where each element is held
+as a member variable. `vector` is the simplest of the Fusion
+sequence container, and in many cases the most efficient.
 
 [heading Header]
 
@@ -96,7 +95,7 @@ including any Fusion header to change the default. Example:
 
 [table
     [[Parameter]            [Description]               [Default]]
-    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
+    [[`T0`...`TN`]          [Element types]             [['unspecified]]]
 ]
 
 [heading Model of]
@@ -157,7 +156,7 @@ time). The runtime cost of access to each element is peculiarly constant
 
 [table
     [[Parameter]            [Description]               [Default]]
-    [[`Car`]                [Head type]                 [ ]]
+    [[`Car`]                [Head type]                 []]
     [[`Cdr`]                [Tail type]                 [`nil`]]
 ]
 
@@ -247,7 +246,7 @@ including any Fusion header to change the default. Example:
 
 [table
     [[Parameter]            [Description]               [Default]]
-    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
+    [[`T0`...`TN`]          [Element types]             [['unspecified-type]]]
 ]
 
 [heading Model of]
@@ -290,220 +289,6 @@ constant (see __recursive_inline__).]
 
 [endsect]
 
-[section deque]
-
-[heading Description]
-
-`deque` is a simple __bidirectional_sequence__ that supports
-constant-time insertion and removal of elements at both ends. Like the
-__list__ and __cons__, `deque` is more efficient than __vector__
-(especially at compile time) when the target sequence is constructed
-piecemeal (a data at a time, e.g. when constructing expression
-templates). Like the __list__ and __cons__, runtime cost of access to
-each element is peculiarly constant (see __recursive_inline__).
-
-Element insertion and removal are done by special `deque` helper classes
-__front_extended_deque__ and __back_extended_deque__.
-
-[heading Header]
-
-    #include <boost/fusion/container/deque.hpp>
-    #include <boost/fusion/include/deque.hpp>
-    #include <boost/fusion/container/list/deque_fwd.hpp>
-    #include <boost/fusion/include/deque_fwd.hpp>
-
-[heading Synopsis]
-
-    template <typename ...Elements>
-    struct deque;
-
-For C++11 compilers, the variadic class interface has no upper bound.
-
-For C++03 compilers, the variadic class interface accepts `0` to
-`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
-user definable predefined maximum that defaults to `10`. Example:
-
-    deque<int, char, double>
-
-You may define the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before
-including any Fusion header to change the default. Example:
-
-    #define FUSION_MAX_DEQUE_SIZE 20
-
-[heading Template parameters]
-
-[table
-    [[Parameter]            [Description]               [Default]]
-    [[`Elements`]           [Element types]             [ ]]
-]
-
-[heading Model of]
-
-* __bidirectional_sequence__
-
-[variablelist Notation
-    [[`D`]              [A `deque` type]]
-    [[`d`, `d2`]        [Instances of `deque`]]
-    [[`e0`...`en`]      [Heterogeneous values]]
-    [[`s`]              [A __forward_sequence__]]
-    [[`N`]              [An __mpl_integral_constant__]]
-]
-
-[heading Expression Semantics]
-
-Semantics of an expression is defined only where it differs from, or is not
-defined in __bidirectional_sequence__.
-
-[table
-    [[Expression]           [Semantics]]
-    [[`D()`]                [Creates a deque with default constructed elements.]]
-    [[`D(e0, e1,... en)`]   [Creates a deque with elements `e0`...`en`.]]
-    [[`D(s)`]               [Copy constructs a deque from a __forward_sequence__, `s`.]]
-    [[`d = s`]              [Assigns to a deque, `d`, from a __forward_sequence__, `s`.]]
-    [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
-]
-
-[blurb __note__ `__at__<N>(d)` is provided for convenience, despite
-`deque` being a __bidirectional_sequence__ only (`at` is supposed to be
-a __random_access_sequence__ requirement). The runtime complexity of
-__at__ is constant (see __recursive_inline__). `deque` element access
-utilizes operator overloading with argument dependent lookup (ADL) of
-the proper element getter function given a static constant index
-parameter. Interestingly, with modern C++ compilers, this lookup is very
-fast and rivals recursive template instantiations in compile time-speed,
-so much so that `deque` relies on ADL for all element access (indexing)
-as well as iteration.]
-
-[heading Example]
-
-    deque<int, float> d(12, 5.5f);
-    std::cout << __at_c__<0>(d) << std::endl;
-    std::cout << __at_c__<1>(d) << std::endl;
-
-[endsect]
-
-[section front_extended_deque]
-
-[heading Description]
-
-`front_extended_deque` allows a __deque__ to be front extended. It shares
-the same properties as the __deque__.
-
-[heading Header]
-
-    See __deque__
-
-[heading Synopsis]
-
-    template <typename Deque, typename T>
-    struct front_extended_deque;
-
-[heading Template parameters]
-
-[table
-    [[Parameter]            [Description]               [Default]]
-    [[`Deque`]              [Deque type]                [ ]]
-    [[`T`]                  [Element type]              [ ]]
-]
-
-[blurb __note__ `Deque` can be a __deque__, a __front_extended_deque__ or a
-__back_extended_deque__]
-
-[heading Model of]
-
-* __bidirectional_sequence__
-
-[variablelist Notation
-    [[`D`]              [A `front_extended_deque` type]]
-    [[`e`]              [Heterogeneous value]]
-    [[`N`]              [An __mpl_integral_constant__]]
-]
-
-[heading Expression Semantics]
-
-Semantics of an expression is defined only where it differs from, or is
-not defined in __bidirectional_sequence__.
-
-[table
-    [[Expression]           [Semantics]]
-    [[`D(d, e)`]            [Extend `d` prepending `e` to its front.]]
-    [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
-]
-
-[blurb __note__ See __deque__ for further details.]
-
-[heading Example]
-
-    typedef deque<int, float> initial_deque;
-    initial_deque d(12, 5.5f);
-    front_extended_deque<initial_deque, int> d2(d, 999);
-    std::cout << __at_c__<0>(d2) << std::endl;
-    std::cout << __at_c__<1>(d2) << std::endl;
-    std::cout << __at_c__<2>(d2) << std::endl;
-
-[endsect]
-
-[section back_extended_deque]
-
-[heading Description]
-
-`back_extended_deque` allows a __deque__ to be back extended. It shares
-the same properties as the __deque__.
-
-[heading Header]
-
-    See __deque__
-
-[heading Synopsis]
-
-    template <typename Deque, typename T>
-    struct back_extended_deque;
-
-[heading Template parameters]
-
-[table
-    [[Parameter]            [Description]               [Default]]
-    [[`Deque`]              [Deque type]                [ ]]
-    [[`T`]                  [Element type]              [ ]]
-]
-
-[blurb __note__ `Deque` can be a __deque__, a __back_extended_deque__ or a
-__back_extended_deque__]
-
-[heading Model of]
-
-* __bidirectional_sequence__
-
-[variablelist Notation
-    [[`D`]              [A `back_extended_deque` type]]
-    [[`e`]              [Heterogeneous value]]
-    [[`N`]              [An __mpl_integral_constant__]]
-]
-
-[heading Expression Semantics]
-
-Semantics of an expression is defined only where it differs from, or is
-not defined in __bidirectional_sequence__.
-
-[table
-    [[Expression]           [Semantics]]
-    [[`D(d, e)`]            [Extend `d` prepending `e` to its back.]]
-    [[`__at__<N>(d)`]       [The Nth element from the beginning of the sequence; see __at__.]]
-]
-
-[blurb __note__ See __deque__ for further details.]
-
-[heading Example]
-
-    typedef deque<int, float> initial_deque;
-    initial_deque d(12, 5.5f);
-    back_extended_deque<initial_deque, int> d2(d, 999);
-    std::cout << __at_c__<0>(d2) << std::endl;
-    std::cout << __at_c__<1>(d2) << std::endl;
-    std::cout << __at_c__<2>(d2) << std::endl;
-
-[endsect]
-
 [section set]
 
 [heading Description]
@@ -547,7 +332,7 @@ including any Fusion header to change the default. Example:
 
 [table
     [[Parameter]            [Description]               [Default]]
-    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
+    [[`T0`...`TN`]          [Element types]             [['unspecified-type]]]
 ]
 
 [heading Model of]
@@ -629,13 +414,13 @@ including any Fusion header to change the default. Example:
 
 [table
     [[Parameter]            [Description]               [Default]]
-    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
+    [[`T0`...`TN`]          [Element types]             [['unspecified-type]]]
 ]
 
 [heading Model of]
 
 * __associative_sequence__
-* __forward_sequence__
+* __random_access_sequence__
 
 [variablelist Notation
     [[`M`]              [A `map` type]]
@@ -647,7 +432,7 @@ including any Fusion header to change the default. Example:
 [heading Expression Semantics]
 
 Semantics of an expression is defined only where it differs from, or is not
-defined in __random_access_sequence__ and __associative_sequence__.
+defined in __forward_sequence__ and __associative_sequence__.
 
 [table
     [[Expression]           [Semantics]]
@@ -832,58 +617,6 @@ __note_boost_ref__
 
 [endsect]
 
-[section make_deque]
-
-[heading Description]
-
-Create a __deque__ from one or more values.
-
-[heading Synopsis]
-
-    template <typename ...Elements>
-    typename __result_of_make_deque__<Elements...>::type
-    make_deque(Elements const&... elements);
-
-For C++11 compilers, the variadic function interface has no upper bound.
-
-For C++11 compilers, the variadic function accepts `0` to
-`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
-user definable predefined maximum that defaults to `10`. You may define
-the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any
-Fusion header to change the default. Example:
-
-    #define FUSION_MAX_DEQUE_SIZE 20
-
-[heading Parameters]
-
-[table
-    [[Parameter]            [Description]               [Description]]
-    [[`elements`]           [Instances of `Elements`]   [The arguments to `make_deque`]]
-]
-
-[heading Expression Semantics]
-
-    make_deque(elements...);
-
-[*Return type]: __result_of_make_deque__`<Elements...>::type`
-
-[*Semantics]: Create a __deque__ from `elements...`.
-
-[heading Header]
-
-    #include <boost/fusion/container/generation/make_deque.hpp>
-    #include <boost/fusion/include/make_deque.hpp>
-
-[heading Example]
-
-    make_deque(123, "hello", 12.5)
-
-[heading See also]
-
-__note_boost_ref__
-
-[endsect]
-
 [section make_set]
 
 [heading Description]
@@ -949,7 +682,7 @@ Create a __map__ from one or more key/data pairs.
       , typename T0, typename T1,... typename TN>
     typename __result_of_make_map__<K0, K0,... KN, T0, T1,... TN>::type
     make_map(T0 const& x0, T1 const& x1... TN const& xN);
-    
+
 The variadic function accepts `0` to `FUSION_MAX_MAP_SIZE` elements,
 where `FUSION_MAX_MAP_SIZE` is a user definable predefined maximum that
 defaults to `10`. You may define the preprocessor constant
@@ -1001,7 +734,6 @@ succeeding sections document the various /tier/ flavors.
 * __list_tie__
 * __vector_tie__
 * __map_tie__
-* __deque_tie__
 
 Example:
 
@@ -1182,56 +914,6 @@ including any Fusion header to change the default. Example:
 
 [endsect]
 
-[section deque_tie]
-
-[heading Description]
-
-Constructs a tie using a __deque__ sequence.
-
-[heading Synopsis]
-
-    template <typename ...Elements>
-    __deque__<Elements&...>
-    deque_tie(Elements&... elements);
-
-For C++11 compilers, the variadic function interface has no upper bound.
-
-For C++03 compilers, the variadic function accepts `0` to
-`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
-user definable predefined maximum that defaults to `10`. You may define
-the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any
-Fusion header to change the default. Example:
-
-    #define FUSION_MAX_DEQUE_SIZE 20
-
-[heading Parameters]
-
-[table
-    [[Parameter]            [Description]               [Description]]
-    [[`elements`]           [Instances of `Elements`]   [The arguments to `deque_tie`]]
-]
-
-[heading Expression Semantics]
-
-    deque_tie(elements...);
-
-[*Return type]: __deque__<Elements&...>
-
-[*Semantics]: Create a __deque__ of references from `elements...`.
-
-[heading Header]
-
-    #include <boost/fusion/container/generation/deque_tie.hpp>
-    #include <boost/fusion/include/deque_tie.hpp>
-
-[heading Example]
-
-    int i = 123;
-    double d = 123.456;
-    deque_tie(i, d)
-
-[endsect]
-
 [endsect]
 
 [section MetaFunctions]
@@ -1357,8 +1039,8 @@ rules for __element_conversion__.
 
 [heading Header]
 
-    #include <boost/fusion/container/generation/make_list.hpp>
-    #include <boost/fusion/include/make_list.hpp>
+    #include <boost/fusion/container/generation/make_vector.hpp>
+    #include <boost/fusion/include/make_vector.hpp>
 
 [heading Example]
 
@@ -1366,54 +1048,6 @@ rules for __element_conversion__.
 
 [endsect]
 
-[section make_deque]
-
-[heading Description]
-
-Returns the result type of __make_deque__.
-
-[heading Synopsis]
-
-    template <typename ...Elements>
-    struct make_deque;
-
-For C++11 compilers, the variadic template interface has no upper bound.
-
-For C++03 The variadic function accepts `0` to `FUSION_MAX_DEQUE_SIZE`
-elements, where `FUSION_MAX_DEQUE_SIZE` is a user definable predefined
-maximum that defaults to `10`. You may define the preprocessor constant
-`FUSION_MAX_DEQUE_SIZE` before including any Fusion header to change the
-default. Example:
-
-    #define FUSION_MAX_DEQUE_SIZE 20
-
-[heading Parameters]
-
-[table
-    [[Parameter]        [Requirement]               [Description]]
-    [[`Elements`]       [Variadic template types]   [Template arguments to `make_deque`]]
-]
-
-[heading Expression Semantics]
-
-    result_of::make_deque<Elements...>::type
-
-[*Return type]: A __deque__ with elements of types converted following the
-rules for __element_conversion__.
-
-[*Semantics]: Create a __deque__ from `Elements...`.
-
-[heading Header]
-
-    #include <boost/fusion/container/generation/make_deque.hpp>
-    #include <boost/fusion/include/make_deque.hpp>
-
-[heading Example]
-
-    result_of::make_deque<int, const char(&)[7], double>::type
-
-[endsect]
-
 [section make_set]
 
 [heading Description]
@@ -1606,53 +1240,6 @@ default. Example:
 
 [endsect]
 
-[section deque_tie]
-
-[heading Description]
-
-Returns the result type of __deque_tie__.
-
-[heading Synopsis]
-
-    template <typename ...Elements>
-    struct deque_tie;
-
-For C++11 compilers, the variadic template interface has no upper bound.
-
-For C++03 compilers, the variadic function accepts `0` to
-`FUSION_MAX_DEQUE_SIZE` elements, where `FUSION_MAX_DEQUE_SIZE` is a
-user definable predefined maximum that defaults to `10`. You may define
-the preprocessor constant `FUSION_MAX_DEQUE_SIZE` before including any
-Fusion header to change the default. Example:
-
-    #define FUSION_MAX_DEQUE_SIZE 20
-
-[heading Parameters]
-
-[table
-    [[Parameter]        [Requirement]               [Description]]
-    [[`Elements`]       [Variadic template types]   [Template arguments to `deque_tie`]]
-]
-
-[heading Expression Semantics]
-
-    result_of::deque_tie<Elements...>::type;
-
-[*Return type]: __deque__<Elements&...>
-
-[*Semantics]: Create a __deque__ of references from `Elements...`.
-
-[heading Header]
-
-    #include <boost/fusion/container/generation/deque_tie.hpp>
-    #include <boost/fusion/include/deque_tie.hpp>
-
-[heading Example]
-
-    result_of::deque_tie<int, double>::type
-
-[endsect]
-
 [section map_tie]
 
 [heading Description]
@@ -1801,48 +1388,6 @@ Convert a fusion sequence to a __vector__.
 
 [endsect]
 
-[section as_deque]
-
-[heading Description]
-
-Convert a fusion sequence to a __deque__.
-
-[heading Synopsis]
-
-    template <typename Sequence>
-    typename result_of::as_deque<Sequence>::type
-    as_deque(Sequence& seq);
-
-    template <typename Sequence>
-    typename result_of::as_deque<Sequence const>::type
-    as_deque(Sequence const& seq);
-
-[heading Parameters]
-
-[table
-    [[Parameter]    [Requirement]               [Description]]
-    [[`seq`]        [An instance of Sequence]   [The sequence to convert.]]
-]
-
-[heading Expression Semantics]
-
-    as_deque(seq);
-
-[*Return type]: __result_of_as_deque__`<Sequence>::type`
-
-[*Semantics]: Convert a fusion sequence, `seq`, to a __deque__.
-
-[heading Header]
-
-    #include <boost/fusion/container/deque/convert.hpp>
-    #include <boost/fusion/include/as_deque.hpp>
-
-[heading Example]
-
-    as_deque(__make_vector__('x', 123, "hello"))
-
-[endsect]
-
 [section as_set]
 
 [heading Description]
@@ -2014,44 +1559,6 @@ Returns the result type of __as_vector__.
 
 [endsect]
 
-[section as_deque]
-
-[heading Description]
-
-Returns the result type of __as_deque__.
-
-[heading Synopsis]
-
-    template <typename Sequence>
-    struct as_deque;
-
-[heading Parameters]
-
-[table
-    [[Parameter]    [Requirement]               [Description]]
-    [[`Sequence`]   [A fusion __sequence__]     [The sequence type to convert.]]
-]
-
-[heading Expression Semantics]
-
-    result_of::as_deque<Sequence>::type;
-
-[*Return type]: A __deque__ with same elements as the input sequence,
-`Sequence`.
-
-[*Semantics]: Convert a fusion sequence, `Sequence`, to a __deque__.
-
-[heading Header]
-
-    #include <boost/fusion/container/deque/convert.hpp>
-    #include <boost/fusion/include/as_deque.hpp>
-
-[heading Example]
-
-    result_of::as_deque<__vector__<char, int> >::type
-
-[endsect]
-
 [section as_set]
 
 [heading Description]

doc/functional.qbk

@@ -66,9 +66,9 @@ function objects to accept arbitrary calls. In other words, an unary function
 object can be implemented instead of (maybe heavily overloaded) function
 templates or function call operators.
 
-The library provides both a strictly typed and a generic variant for this 
+The library provides both a strictly typed and a generic variant for this
 transformation. The latter should be used in combination with
-__boost_func_forward__ to attack __the_forwarding_problem__. 
+__boost_func_forward__ to attack __the_forwarding_problem__.
 
 Both variants have a corresponding generator function template that returns an
 adapter instance for the given argument.
@@ -546,7 +546,7 @@ Returns the result type of __invoke_function_object__.
 
 [heading Macros]
 
-The following macros can be defined to change the maximum arity. 
+The following macros can be defined to change the maximum arity.
 The default is 6.
 
 * BOOST_FUSION_INVOKE_MAX_ARITY
@@ -1060,7 +1060,7 @@ signature is optimized automatically to avoid by-value parameters.]
 
 [heading Macros]
 
-The following macros can be defined to change the maximum arity. 
+The following macros can be defined to change the maximum arity.
 The value used for these macros must not exceed `FUSION_MAX_VECTOR_SIZE`.
 The default is 6.
 

doc/fusion.qbk

@@ -9,9 +9,9 @@
 ===============================================================================/]
 [library Fusion
     [quickbook 1.3]
-    [version 2.1]
+    [version 2.2]
     [authors [de Guzman, Joel], [Marsden, Dan], [Schwinger, Tobias]]
-    [copyright 2001 2002 2003 2004 2005 2006 2011 2012 Joel de Guzman, Dan Marsden, Tobias Schwinger]
+    [copyright 2001 2002 2003 2004 2005 2006 2011 Joel de Guzman, Dan Marsden, Tobias Schwinger]
     [purpose Statically Typed Heterogeneous Data Structures and Algorithms]
     [license
         Distributed under the Boost Software License, Version 1.0.
@@ -116,9 +116,6 @@
 [def __vector__                 [link fusion.container.vector `vector`]]
 [def __cons__                   [link fusion.container.cons `cons`]]
 [def __list__                   [link fusion.container.list `list`]]
-[def __deque__                  [link fusion.container.deque `deque`]]
-[def __front_extended_deque__   [link fusion.container.front_extended_deque `front_extended_deque`]]
-[def __back_extended_deque__    [link fusion.container.back_extended_deque `back_extended_deque`]]
 [def __set__                    [link fusion.container.set `set`]]
 [def __map__                    [link fusion.container.map `map`]]
 
@@ -201,16 +198,12 @@
 [def __result_of_make_cons__    [link fusion.container.generation.metafunctions.make_cons `result_of::make_cons`]]
 [def __make_list__              [link fusion.container.generation.functions.make_list `make_list`]]
 [def __result_of_make_list__    [link fusion.container.generation.metafunctions.make_list `result_of::make_list`]]
-[def __make_deque__             [link fusion.container.generation.functions.make_deque `make_deque`]]
-[def __result_of_make_deque__   [link fusion.container.generation.metafunctions.make_deque `result_of::make_deque`]]
 [def __make_set__               [link fusion.container.generation.functions.make_set `make_set`]]
 [def __result_of_make_set__     [link fusion.container.generation.metafunctions.make_set `result_of::make_set`]]
 [def __make_map__               [link fusion.container.generation.functions.make_map `make_map`]]
 [def __result_of_make_map__     [link fusion.container.generation.metafunctions.make_map `result_of::make_map`]]
 [def __list_tie__               [link fusion.container.generation.functions.list_tie `list_tie`]]
 [def __result_of_list_tie__     [link fusion.container.generation.metafunctions.list_tie `result_of::list_tie`]]
-[def __deque_tie__              [link fusion.container.generation.functions.deque_tie `deque_tie`]]
-[def __result_of_deque_tie__    [link fusion.container.generation.metafunctions.deque_tie `result_of::deque_tie`]]
 
 [def __out__                    [link fusion.sequence.operator.i_o.out out]]
 [def __in__                     [link fusion.sequence.operator.i_o.in in]]

doc/html/index.html

@@ -1,6 +1,6 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
-<head>
+  <head>
   <!-- Copyright (C) 2002 Douglas Gregor <doug.gregor -at- gmail.com>
 
       Distributed under the Boost Software License, Version 1.0.
@@ -8,9 +8,9 @@
       http://www.boost.org/LICENSE_1_0.txt) -->
     <title>Redirect to generated documentation</title>
     <meta http-equiv="refresh" content="0; URL=http://boost-sandbox.sourceforge.net/libs/fusion/doc/html/">
-</head>
+  </head>
   <body>
     Automatic redirection failed, please go to
     <a href="http://boost-sandbox.sourceforge.net/libs/fusion/doc/html/">http://boost-sandbox.sourceforge.net/libs/fusion/doc/html/</a>
-</body>
+  </body>
 </html>

doc/iterator.qbk

@@ -161,6 +161,7 @@ the following invariants always hold:
 * __std_pair__ iterator
 * __boost_array__ iterator
 * __vector__ iterator
+* __map__ iterator
 * __single_view__ iterator
 * __iterator_range__ (where adapted sequence is a __bidirectional_sequence__)
 * __transform_view__ (where adapted sequence is a __bidirectional_sequence__)
@@ -206,6 +207,7 @@ the following expressions must be valid:
 
 [heading Models]
 * __vector__ iterator
+* __map__ iterator
 * __std_pair__ iterator
 * __boost_array__ iterator
 * __single_view__ iterator
@@ -492,7 +494,7 @@ Deferences the data property associated with the element referenced by an associ
     template<
         typename I
         >
-    typename __result_of_deref_data__<I>::type deref_data(I const& i);
+    typename __result_of_deref_data__<I>::type deref(I const& i);
 
 [table Parameters
     [[Parameter]      [Requirement]    [Description]]
@@ -993,9 +995,9 @@ Returns the key type associated with the element referenced by an associative it
 [heading Example]
     typedef __map__<__pair__<float,int> > vec;
     typedef __result_of_begin__<vec>::type first;
-	
+
     BOOST_MPL_ASSERT((boost::is_same<__result_of_key_of__<first>::type, float>));
-    
+
 [endsect]
 
 [section value_of_data]
@@ -1032,9 +1034,9 @@ Returns the type of the data property associated with the element referenced by
 [heading Example]
     typedef __map__<__pair__<float,int> > vec;
     typedef __result_of_begin__<vec>::type first;
-	
+
     BOOST_MPL_ASSERT((boost::is_same<__result_of_value_of_data__<first>::type, int>));
-    
+
 [endsect]
 
 [section deref_data]

doc/notes.qbk

@@ -168,7 +168,7 @@ and __deref_data__) is a proxy type, an instance of
 has three template arguments:
 
     namespace boost { namespace fusion { namespace extension
-    {    
+    {
         template<
             typename Type
           , int Index
@@ -176,14 +176,14 @@ has three template arguments:
         >
         struct adt_attribute_proxy;
     }}}
-    
+
 When adapting a class type, `adt_attribute_proxy` is specialized for every
 element of the adapted sequence, with `Type` being the class type that is
 adapted, `Index` the 0-based indices of the elements, and `Const` both `true`
 and `false`. The return type of fusion's intrinsic sequence access functions
 for the ['N]th element of an adapted class type `type_name` is
 [^adt_attribute_proxy<type_name, ['N], ['Const]>], with [^['Const]] being `true`
-for constant instances of `type_name` and `false` for non-constant ones. 
+for constant instances of `type_name` and `false` for non-constant ones.
 
 [variablelist Notation
     [[`type_name`]
@@ -205,7 +205,7 @@ for constant instances of `type_name` and `false` for non-constant ones.
 ]
 
 [*Expression Semantics]
- 
+
 [table
     [[Expression]                     [Semantics]]
     [[[^proxy_type['N](inst)]]             [Creates an instance of [^proxy_type['N]] with underlying object `inst`]]

doc/sequence.qbk

@@ -189,6 +189,7 @@ are not defined in __forward_sequence__.
 * __std_pair__
 * __boost_array__
 * __vector__
+* __map__
 * __reverse_view__
 * __single_view__
 * __iterator_range__ (where adapted sequence is a Bidirectional Sequence)
@@ -265,6 +266,7 @@ are not defined in __bidirectional_sequence__.
 * __std_pair__
 * __boost_array__
 * __vector__
+* __map__
 * __reverse_view__
 * __single_view__
 * __iterator_range__ (where adapted sequence is a Random Access Sequence)
@@ -848,7 +850,7 @@ Performs an element by element swap of the elements in 2 sequences.
 
 [table
     [[Parameters]    [Requirement]                           [Description]]
-    [[`seq1`, `seq2`]        [Models of __forward_sequence__][The sequences whos elements we wish to swap.]]
+    [[`seq1`, `seq2`][Models of __forward_sequence__][The sequences whos elements we wish to swap.]]
 ]
 
 [heading Expression Semantics]
@@ -1376,7 +1378,7 @@ Returns the actual element type associated with a Key from the __sequence__.
 
     #include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
     #include <boost/fusion/include/value_at_key.hpp>
-    
+
 [heading Example]
     typedef __map__<__pair__<int, char>, __pair__<char, char>, __pair__<double, char> > mymap;
     BOOST_MPL_ASSERT((boost::is_same<__result_of_at_key__<mymap, int>::type, char>));

doc/tuple.qbk

@@ -91,7 +91,7 @@ Where `Vi` is `X&` if the cv-unqualified type `Ti` is `reference_wrapper<X>`, ot
     template<typename T1, typename T2, ..., typename TN>
     tuple<T1&, T2&, ..., TN&> tie(T1& t1, T2& t2, ..., TN& tn);
 
-[*Returns]: tuple<T1&, T2&, ..., TN&>(t1, t2, ..., tN). When argument `ti` is `ignore`, assigning any value to the corresponding tuple element has no effect.
+[*Returns]: tuple<T1&, T2&, ..., TN&>(t1, t2, ..., tN). When argument `ti` is `ignore`, assigning any value to the corresponding tuple element has has no effect.
 
 [endsect]
 
@@ -254,7 +254,7 @@ The __tr1__tuple__ interface is specified to provide uniform access to `std::pai
 
 [*Type]: `T2`
 
-[*Value]: Returns the type of the second element of the pair
+[*Value]: Returns thetype of the second element of the pair
 
     template<int I, typename T1, typename T2>
     P& get(std::pair<T1, T2>& pr);

doc/view.qbk

@@ -483,7 +483,7 @@ defined in the implemented models.
 
 [heading Description]
 
-`nview` presents a view which iterates over a given __sequence__ in a specified order. 
+`nview` presents a view which iterates over a given __sequence__ in a specified order.
 An `nview` is constructed from an arbitrary __sequence__ and a list of indicies specifying
 the elements to iterate over.
 
@@ -507,15 +507,15 @@ the elements to iterate over.
     [[Parameter]            [Description]                   [Default]]
     [[`Sequence`]           [An arbitrary Fusion __forward_sequence__]
                                                             []]
-    [[`Indicies`]           [A `mpl::vector_c<int, ...>` holding the indicies defining 
+    [[`Indicies`]           [A `mpl::vector_c<int, ...>` holding the indicies defining
                              the required iteration order.] []]
-    [[`I1`, `I2`, `I3`...]  [A list of integers specifying the required 
+    [[`I1`, `I2`, `I3`...]  [A list of integers specifying the required
                              iteration order.]              [`INT_MAX` for `I2`, `I3`...]]
 ]
 
 [heading Model of]
 
-* __random_access_sequence__ (see __traversal_concept__) 
+* __random_access_sequence__ (see __traversal_concept__)
 
 [variablelist Notation
     [[`NV`]            [A `nview` type]]

example/extension/triple.cpp

@@ -3,7 +3,7 @@
     Copyright (c) 2011 Nathan Ridge
     Copyright (c) 2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 

include/boost/fusion/adapted.hpp

@@ -18,7 +18,7 @@
 
 // The std_tuple_iterator adaptor only supports implementations
 // using variadic templates
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#if !defined(BOOST_NO_VARIADIC_TEMPLATES)
 #include <boost/fusion/adapted/std_tuple.hpp>
 #endif
 

include/boost/fusion/adapted/adt/detail/extension.hpp

@@ -12,28 +12,13 @@
 
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_reference.hpp>
-#include <boost/fusion/support/as_const.hpp>
-#include <boost/fusion/adapted/struct/detail/extension.hpp>
 
-namespace boost { namespace fusion
-{ 
-    namespace detail
-    {
+namespace boost { namespace fusion { namespace detail
+{
     template <typename T, typename Dummy>
     struct get_identity
       : remove_const<typename remove_reference<T>::type>
     {};
-    }
-    
-    namespace extension
-    {
-        // Overload as_const() to unwrap adt_attribute_proxy.
-        template <typename T, int N, bool Const>
-        typename adt_attribute_proxy<T, N, Const>::type as_const(const adt_attribute_proxy<T, N, Const>& proxy)
-        {
-            return proxy.get();
-        }
-    }
-}}
+}}}
 
 #endif

include/boost/fusion/adapted/std_tuple/detail/at_impl.hpp

@@ -9,7 +9,7 @@
 
 #include <tuple>
 #include <utility>
-#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/fusion/support/detail/access.hpp>
 #include <boost/type_traits/remove_const.hpp>
 
@@ -29,13 +29,13 @@ namespace boost { namespace fusion
             struct apply
             {
                 typedef typename remove_const<Sequence>::type seq_type;
-                typedef typename std::tuple_element<N::value, seq_type>::type element;
+                typedef std::tuple_element<N::value, seq_type> element;
 
                 typedef typename
-                    mpl::if_<
+                    mpl::eval_if<
                         is_const<Sequence>
-                      , typename fusion::detail::cref_result<element>::type
-                      , typename fusion::detail::ref_result<element>::type
+                      , fusion::detail::cref_result<element>
+                      , fusion::detail::ref_result<element>
                     >::type
                 type;
 

include/boost/fusion/adapted/std_tuple/std_tuple_iterator.hpp

@@ -12,7 +12,7 @@
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/fusion/support/detail/access.hpp>
 #include <boost/mpl/int.hpp>
-#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <tuple>
 #include <utility>
 
@@ -48,12 +48,12 @@ namespace boost { namespace fusion
         template <typename Iterator>
         struct deref
         {
-            typedef typename value_of<Iterator>::type element;
+            typedef value_of<Iterator> element;
             typedef typename
-                mpl::if_<
+                mpl::eval_if<
                     is_const<typename Iterator::tuple_type>
-                  , typename fusion::detail::cref_result<element>::type
-                  , typename fusion::detail::ref_result<element>::type
+                  , fusion::detail::cref_result<element>
+                  , fusion::detail::ref_result<element>
                 >::type
             type;
 

include/boost/fusion/adapted/std_tuple/tag_of.hpp

@@ -10,6 +10,12 @@
 #include <tuple>
 #include <boost/fusion/support/tag_of_fwd.hpp>
 
+namespace std
+{
+    template <typename... Elements>
+    class tuple;
+}
+
 namespace boost { namespace fusion
 {
     struct std_tuple_tag;

include/boost/fusion/adapted/struct.hpp

@@ -16,6 +16,5 @@
 #include <boost/fusion/adapted/struct/adapt_struct.hpp>
 #include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
 #include <boost/fusion/adapted/struct/define_struct.hpp>
-#include <boost/fusion/adapted/struct/define_struct_inline.hpp>
 
 #endif

include/boost/fusion/adapted/struct/define_struct_inline.hpp

@@ -1,25 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2012 Nathan Ridge
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-
-#ifndef BOOST_FUSION_ADAPTED_STRUCT_DEFINE_STRUCT_INLINE_HPP
-#define BOOST_FUSION_ADAPTED_STRUCT_DEFINE_STRUCT_INLINE_HPP
-
-#include <boost/fusion/adapted/struct/adapt_struct.hpp>
-#include <boost/fusion/adapted/struct/detail/define_struct_inline.hpp>
-
-#define BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE(                                  \
-    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES)                                      \
-                                                                                \
-    BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE_IMPL(                                 \
-        TEMPLATE_PARAMS_SEQ,                                                    \
-        NAME,                                                                   \
-        ATTRIBUTES)
-
-#define BOOST_FUSION_DEFINE_STRUCT_INLINE(NAME, ATTRIBUTES)                     \
-    BOOST_FUSION_DEFINE_STRUCT_INLINE_IMPL(NAME, ATTRIBUTES)                    \
-
-#endif

include/boost/fusion/adapted/struct/detail/define_struct_inline.hpp

@@ -1,523 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2012 Nathan Ridge
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-
-#ifndef BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEFINE_STRUCT_INLINE_HPP
-#define BOOST_FUSION_ADAPTED_STRUCT_DETAIL_DEFINE_STRUCT_INLINE_HPP
-
-#include <boost/config.hpp>
-#include <boost/fusion/support/category_of.hpp>
-#include <boost/fusion/sequence/sequence_facade.hpp>
-#include <boost/fusion/iterator/iterator_facade.hpp>
-#include <boost/fusion/algorithm/auxiliary/copy.hpp>
-#include <boost/fusion/adapted/struct/detail/define_struct.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/minus.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/preprocessor/comma_if.hpp>
-#include <boost/preprocessor/facilities/is_empty.hpp>
-#include <boost/preprocessor/repeat.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-#include <boost/preprocessor/seq/seq.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-
-// MSVC and GCC <= 4.4 have a bug that affects partial specializations of
-// nested templates under some circumstances. This affects the implementation
-// of BOOST_FUSION_DEFINE_STRUCT_INLINE, which uses such specializations for
-// the iterator class's 'deref' and 'value_of' metafunctions. On these compilers
-// an alternate implementation for these metafunctions is used that does not 
-// require such specializations. The alternate implementation takes longer
-// to compile so its use is restricted to the offending compilers.
-// For MSVC, the bug was was reported at https://connect.microsoft.com/VisualStudio/feedback/details/757891/c-compiler-error-involving-partial-specializations-of-nested-templates
-// For GCC, 4.4 and earlier are no longer maintained so there is no need
-// to report a bug.
-#if defined(BOOST_MSVC) || (defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 4)))
-    #define BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND 
-#endif
-
-#ifdef BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/fusion/sequence/intrinsic/at_c.hpp>
-#include <boost/fusion/container/vector.hpp>
-#endif
-
-
-#define BOOST_FUSION_MAKE_DEFAULT_INIT_LIST_ENTRY(R, DATA, N, ATTRIBUTE)        \
-    BOOST_PP_COMMA_IF(N) BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)()
-
-#define BOOST_FUSION_MAKE_DEFAULT_INIT_LIST(ATTRIBUTES_SEQ)                     \
-            : BOOST_PP_SEQ_FOR_EACH_I(                                          \
-              BOOST_FUSION_MAKE_DEFAULT_INIT_LIST_ENTRY,                        \
-              ~,                                                                \
-              ATTRIBUTES_SEQ)                                                   \
-
-#define BOOST_FUSION_IGNORE_1(ARG1)
-#define BOOST_FUSION_IGNORE_2(ARG1, ARG2)
-
-#define BOOST_FUSION_MAKE_COPY_CONSTRUCTOR(NAME, ATTRIBUTES_SEQ)                \
-    NAME(BOOST_PP_SEQ_FOR_EACH_I(                                               \
-            BOOST_FUSION_MAKE_CONST_REF_PARAM,                                  \
-            ~,                                                                  \
-            ATTRIBUTES_SEQ))                                                    \
-        : BOOST_PP_SEQ_FOR_EACH_I(                                              \
-              BOOST_FUSION_MAKE_INIT_LIST_ENTRY,                                \
-              ~,                                                                \
-              ATTRIBUTES_SEQ)                                                   \
-    {                                                                           \
-    }                                                                           \
-
-#define BOOST_FUSION_MAKE_CONST_REF_PARAM(R, DATA, N, ATTRIBUTE)                \
-    BOOST_PP_COMMA_IF(N)                                                        \
-    BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) const&                                 \
-    BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)
-
-#define BOOST_FUSION_MAKE_INIT_LIST_ENTRY_I(NAME) NAME(NAME)
-
-#define BOOST_FUSION_MAKE_INIT_LIST_ENTRY(R, DATA, N, ATTRIBUTE)                \
-    BOOST_PP_COMMA_IF(N)                                                        \
-    BOOST_FUSION_MAKE_INIT_LIST_ENTRY_I(BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE))
-
-#define BOOST_FUSION_ITERATOR_NAME(NAME)                                        \
-    BOOST_PP_CAT(boost_fusion_detail_, BOOST_PP_CAT(NAME, _iterator))
-
-// Note: all template parameter names need to be uglified, otherwise they might
-//       shadow a template parameter of the struct when used with
-//       BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE
-
-#define BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS(Z, N, NAME)                   \
-    template <typename boost_fusion_detail_Sq>                                  \
-    struct value_of<                                                            \
-               BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, N>      \
-           >                                                                    \
-        : boost::mpl::identity<                                                 \
-              typename boost_fusion_detail_Sq::t##N##_type                      \
-          >                                                                     \
-    {                                                                           \
-    };
-
-#define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC(                                  \
-    SPEC_TYPE, CALL_ARG_TYPE, TYPE_QUAL, ATTRIBUTE, N)                          \
-                                                                                \
-    template <typename boost_fusion_detail_Sq>                                  \
-    struct deref<SPEC_TYPE, N> >                                                \
-    {                                                                           \
-        typedef typename boost_fusion_detail_Sq::t##N##_type TYPE_QUAL& type;   \
-        static type call(CALL_ARG_TYPE, N> const& iter)                         \
-        {                                                                       \
-            return iter.seq_.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE);              \
-        }                                                                       \
-    };
-
-#define BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS(R, NAME, N, ATTRIBUTE)           \
-    BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC(                                      \
-        BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq,                \
-        BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq,                \
-        ,                                                                       \
-        ATTRIBUTE,                                                              \
-        N)                                                                      \
-    BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC(                                      \
-        BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq,          \
-        BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq,          \
-        const,                                                                  \
-        ATTRIBUTE,                                                              \
-        N)                                                                      \
-    BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC(                                      \
-        const BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq,          \
-        BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq,                \
-        ,                                                                       \
-        ATTRIBUTE,                                                              \
-        N)                                                                      \
-    BOOST_FUSION_MAKE_ITERATOR_DEREF_SPEC(                                      \
-        const BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq,    \
-        BOOST_FUSION_ITERATOR_NAME(NAME)<const boost_fusion_detail_Sq,          \
-        const,                                                                  \
-        ATTRIBUTE,                                                              \
-        N)                                                                      \
-
-#define BOOST_FUSION_MAKE_VALUE_AT_SPECS(Z, N, DATA)                            \
-    template <typename boost_fusion_detail_Sq>                                  \
-    struct value_at<boost_fusion_detail_Sq, boost::mpl::int_<N> >               \
-    {                                                                           \
-        typedef typename boost_fusion_detail_Sq::t##N##_type type;              \
-    };
-
-#define BOOST_FUSION_MAKE_AT_SPECS(R, DATA, N, ATTRIBUTE)                       \
-    template <typename boost_fusion_detail_Sq>                                  \
-    struct at<boost_fusion_detail_Sq, boost::mpl::int_<N> >                     \
-    {                                                                           \
-        typedef typename boost::mpl::if_<                                       \
-            boost::is_const<boost_fusion_detail_Sq>,                            \
-            typename boost_fusion_detail_Sq::t##N##_type const&,                \
-            typename boost_fusion_detail_Sq::t##N##_type&                       \
-        >::type type;                                                           \
-                                                                                \
-        static type call(boost_fusion_detail_Sq& sq)                            \
-        {                                                                       \
-            return sq. BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE);                    \
-        }                                                                       \
-    };
-
-#define BOOST_FUSION_MAKE_TYPEDEF(R, DATA, N, ATTRIBUTE)                        \
-    typedef BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) t##N##_type;
-
-#define BOOST_FUSION_MAKE_DATA_MEMBER(R, DATA, N, ATTRIBUTE)                    \
-    BOOST_PP_TUPLE_ELEM(2, 0, ATTRIBUTE) BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE);
-
-#ifdef BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND
-
-#define BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTE_SEQ_SIZE)         \
-        template <typename boost_fusion_detail_Iterator>                        \
-        struct value_of : boost::fusion::result_of::at_c<                       \
-                              ref_vec_t,                                        \
-                              boost_fusion_detail_Iterator::index::value        \
-                          >                                                     \
-        {                                                                       \
-        };
-
-#define BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ)                \
-        template <typename boost_fusion_detail_Iterator>                        \
-        struct deref                                                            \
-        {                                                                       \
-            typedef typename boost::remove_const<                               \
-                boost_fusion_detail_Iterator                                    \
-            >::type iterator_raw_type;                                          \
-                                                                                \
-            static const int index = iterator_raw_type::index::value;           \
-                                                                                \
-            typedef typename boost::fusion::result_of::at_c<                    \
-                ref_vec_t,                                                      \
-                index                                                           \
-            >::type result_raw_type;                                            \
-                                                                                \
-            typedef typename boost::mpl::if_<                                   \
-                boost::is_const<typename iterator_raw_type::sequence_type>,     \
-                typename boost::add_const<result_raw_type>::type,               \
-                result_raw_type                                                 \
-            >::type type;                                                       \
-                                                                                \
-            static type call(iterator_raw_type const& iter)                     \
-            {                                                                   \
-                return boost::fusion::at_c<index>(iter.ref_vec);                \
-            }                                                                   \
-        };
-
-#define BOOST_FUSION_MAKE_ITERATOR_WKND_FIELD_NAME(R, DATA, N, ATTRIBUTE)       \
-        BOOST_PP_COMMA_IF(N) seq.BOOST_PP_TUPLE_ELEM(2, 1, ATTRIBUTE)
-
-#define BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES(ATTRIBUTES_SEQ)     \
-        , ref_vec(BOOST_PP_SEQ_FOR_EACH_I(                                      \
-                          BOOST_FUSION_MAKE_ITERATOR_WKND_FIELD_NAME,           \
-                          ~,                                                    \
-                          BOOST_PP_SEQ_TAIL(ATTRIBUTES_SEQ)))
-
-#define BOOST_FUSION_MAKE_ITERATOR_WKND_REF(Z, N, DATA)                         \
-        BOOST_PP_COMMA_IF(N)                                                    \
-        typename boost::mpl::if_<                                               \
-                boost::is_const<boost_fusion_detail_Seq>,                       \
-                typename boost::add_const<                                      \
-                        typename boost_fusion_detail_Seq::t##N##_type           \
-                >::type,                                                        \
-                typename boost_fusion_detail_Seq::t##N##_type                   \
-        >::type&
-
-#define BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE)          \
-        typedef boost::fusion::vector<                                          \
-            BOOST_PP_REPEAT(                                                    \
-                    ATTRIBUTES_SEQ_SIZE,                                        \
-                    BOOST_FUSION_MAKE_ITERATOR_WKND_REF,                        \
-                    ~)                                                          \
-        > ref_vec_t;                                                            \
-                                                                                \
-        ref_vec_t ref_vec;
-
-#else
-
-#define BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTES_SEQ_SIZE)        \
-        template <typename boost_fusion_detail_T> struct value_of;              \
-        BOOST_PP_REPEAT(                                                        \
-            ATTRIBUTES_SEQ_SIZE,                                                \
-            BOOST_FUSION_MAKE_ITERATOR_VALUE_OF_SPECS,                          \
-            NAME)
-
-#define BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ)                \
-        template <typename boost_fusion_detail_T> struct deref;                 \
-        BOOST_PP_SEQ_FOR_EACH_I(                                                \
-            BOOST_FUSION_MAKE_ITERATOR_DEREF_SPECS,                             \
-            NAME,                                                               \
-            ATTRIBUTES_SEQ)
-
-#define BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES(ATTRIBUTES_SEQ)
-
-#define BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE)
-
-#endif  // BOOST_FUSION_NEED_NESTED_TEMPLATE_PARTIAL_SPEC_WKND
-
-// Note: We can't nest the iterator inside the struct because we run into
-//       a MSVC10 bug involving partial specializations of nested templates.
-
-#define BOOST_FUSION_DEFINE_STRUCT_INLINE_IMPL(NAME, ATTRIBUTES)                \
-    BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES)                \
-    struct NAME : boost::fusion::sequence_facade<                               \
-                      NAME,                                                     \
-                      boost::fusion::random_access_traversal_tag                \
-                  >                                                             \
-    {                                                                           \
-        BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES)             \
-    };
-
-#define BOOST_FUSION_DEFINE_TPL_STRUCT_INLINE_IMPL(                             \
-    TEMPLATE_PARAMS_SEQ, NAME, ATTRIBUTES)                                      \
-                                                                                \
-    BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES)                \
-                                                                                \
-    template <                                                                  \
-        BOOST_FUSION_ADAPT_STRUCT_UNPACK_TEMPLATE_PARAMS_IMPL(                  \
-            (0)TEMPLATE_PARAMS_SEQ)                                             \
-    >                                                                           \
-    struct NAME : boost::fusion::sequence_facade<                               \
-                      NAME<                                                     \
-                          BOOST_PP_SEQ_ENUM(TEMPLATE_PARAMS_SEQ)                \
-                      >,                                                        \
-                      boost::fusion::random_access_traversal_tag                \
-                  >                                                             \
-    {                                                                           \
-        BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES)             \
-    };
-
-#define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS(NAME, ATTRIBUTES)             \
-    BOOST_FUSION_DEFINE_STRUCT_MEMBERS_IMPL(                                    \
-        NAME,                                                                   \
-        BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END))
-
-// Note: can't compute BOOST_PP_SEQ_SIZE(ATTRIBUTES_SEQ) directly because
-//       ATTRIBUTES_SEQ may be empty and calling BOOST_PP_SEQ_SIZE on an empty
-//       sequence produces warnings on MSVC.
-#define BOOST_FUSION_DEFINE_STRUCT_MEMBERS_IMPL(NAME, ATTRIBUTES_SEQ)           \
-    BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL(                        \
-        NAME,                                                                   \
-        ATTRIBUTES_SEQ,                                                         \
-        BOOST_PP_DEC(BOOST_PP_SEQ_SIZE((0)ATTRIBUTES_SEQ)))
-
-#define BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR(NAME, ATTRIBUTES)            \
-    BOOST_FUSION_DEFINE_STRUCT_ITERATOR_IMPL(                                   \
-        NAME,                                                                   \
-        BOOST_PP_CAT(BOOST_FUSION_ADAPT_STRUCT_FILLER_0 ATTRIBUTES,_END))
-
-#define BOOST_FUSION_DEFINE_STRUCT_ITERATOR_IMPL(NAME, ATTRIBUTES_SEQ)          \
-    BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR_IMPL_IMPL(                       \
-        NAME,                                                                   \
-        ATTRIBUTES_SEQ,                                                         \
-        BOOST_PP_DEC(BOOST_PP_SEQ_SIZE((0)ATTRIBUTES_SEQ)))
-
-#define BOOST_FUSION_DEFINE_STRUCT_INLINE_ITERATOR_IMPL_IMPL(                   \
-    NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE)                                  \
-                                                                                \
-    template <typename boost_fusion_detail_Seq, int N>                          \
-    struct BOOST_FUSION_ITERATOR_NAME(NAME)                                     \
-        : boost::fusion::iterator_facade<                                       \
-              BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Seq, N>,     \
-              boost::fusion::random_access_traversal_tag                        \
-          >                                                                     \
-    {                                                                           \
-        typedef boost::mpl::int_<N> index;                                      \
-        typedef boost_fusion_detail_Seq sequence_type;                          \
-                                                                                \
-        BOOST_FUSION_ITERATOR_NAME(NAME)(boost_fusion_detail_Seq& seq)          \
-            : seq_(seq)                                                         \
-              BOOST_FUSION_DEFINE_ITERATOR_WKND_INIT_LIST_ENTRIES(              \
-                      (0)ATTRIBUTES_SEQ)                                        \
-        {}                                                                      \
-                                                                                \
-        boost_fusion_detail_Seq& seq_;                                          \
-                                                                                \
-        BOOST_FUSION_DEFINE_ITERATOR_WKND_MEMBERS(ATTRIBUTES_SEQ_SIZE)          \
-                                                                                \
-        BOOST_FUSION_DEFINE_ITERATOR_VALUE_OF(NAME, ATTRIBUTES_SEQ_SIZE)        \
-                                                                                \
-        BOOST_FUSION_DEFINE_ITERATOR_DEREF(NAME, ATTRIBUTES_SEQ)                \
-                                                                                \
-        template <typename boost_fusion_detail_It>                              \
-        struct next                                                             \
-        {                                                                       \
-            typedef BOOST_FUSION_ITERATOR_NAME(NAME)<                           \
-                typename boost_fusion_detail_It::sequence_type,                 \
-                boost_fusion_detail_It::index::value + 1                        \
-            > type;                                                             \
-                                                                                \
-            static type call(boost_fusion_detail_It const& it)                  \
-            {                                                                   \
-                return type(it.seq_);                                           \
-            }                                                                   \
-        };                                                                      \
-                                                                                \
-        template <typename boost_fusion_detail_It>                              \
-        struct prior                                                            \
-        {                                                                       \
-            typedef BOOST_FUSION_ITERATOR_NAME(NAME)<                           \
-                typename boost_fusion_detail_It::sequence_type,                 \
-                boost_fusion_detail_It::index::value - 1                        \
-            > type;                                                             \
-                                                                                \
-            static type call(boost_fusion_detail_It const& it)                  \
-            {                                                                   \
-                return type(it.seq_);                                           \
-            }                                                                   \
-        };                                                                      \
-                                                                                \
-        template <                                                              \
-            typename boost_fusion_detail_It1,                                   \
-            typename boost_fusion_detail_It2                                    \
-        >                                                                       \
-        struct distance                                                         \
-        {                                                                       \
-            typedef typename boost::mpl::minus<                                 \
-                typename boost_fusion_detail_It2::index,                        \
-                typename boost_fusion_detail_It1::index                         \
-            >::type type;                                                       \
-                                                                                \
-             static type call(boost_fusion_detail_It1 const& it1,               \
-                              boost_fusion_detail_It2 const& it2)               \
-            {                                                                   \
-                return type();                                                  \
-            }                                                                   \
-        };                                                                      \
-                                                                                \
-        template <                                                              \
-            typename boost_fusion_detail_It,                                    \
-            typename boost_fusion_detail_M                                      \
-        >                                                                       \
-        struct advance                                                          \
-        {                                                                       \
-            typedef BOOST_FUSION_ITERATOR_NAME(NAME)<                           \
-                typename boost_fusion_detail_It::sequence_type,                 \
-                boost_fusion_detail_It::index::value                            \
-                    + boost_fusion_detail_M::value                              \
-            > type;                                                             \
-                                                                                \
-            static type call(boost_fusion_detail_It const& it)                  \
-            {                                                                   \
-                return type(it.seq_);                                           \
-            }                                                                   \
-        };                                                                      \
-    };
-
-
-#define BOOST_FUSION_DEFINE_STRUCT_INLINE_MEMBERS_IMPL_IMPL(                    \
-    NAME, ATTRIBUTES_SEQ, ATTRIBUTES_SEQ_SIZE)                                  \
-                                                                                \
-    /* Note: second BOOST_PP_IF is necessary to avoid MSVC warning when */      \
-    /*       calling BOOST_FUSION_IGNORE_1 with no arguments.           */      \
-    NAME()                                                                      \
-        BOOST_PP_IF(                                                            \
-            ATTRIBUTES_SEQ_SIZE,                                                \
-            BOOST_FUSION_MAKE_DEFAULT_INIT_LIST,                                \
-            BOOST_FUSION_IGNORE_1)                                              \
-                (BOOST_PP_IF(                                                   \
-                    ATTRIBUTES_SEQ_SIZE,                                        \
-                    ATTRIBUTES_SEQ,                                             \
-                    0))                                                         \
-    {                                                                           \
-    }                                                                           \
-                                                                                \
-    BOOST_PP_IF(                                                                \
-        ATTRIBUTES_SEQ_SIZE,                                                    \
-        BOOST_FUSION_MAKE_COPY_CONSTRUCTOR,                                     \
-        BOOST_FUSION_IGNORE_2)                                                  \
-            (NAME, ATTRIBUTES_SEQ)                                              \
-                                                                                \
-    template <typename boost_fusion_detail_Seq>                                 \
-    NAME(const boost_fusion_detail_Seq& rhs)                                    \
-    {                                                                           \
-        boost::fusion::copy(rhs, *this);                                        \
-    }                                                                           \
-                                                                                \
-    template <typename boost_fusion_detail_Seq>                                 \
-    NAME& operator=(const boost_fusion_detail_Seq& rhs)                         \
-    {                                                                           \
-        boost::fusion::copy(rhs, *this);                                        \
-        return *this;                                                           \
-    }                                                                           \
-                                                                                \
-    template <typename boost_fusion_detail_Sq>                                  \
-    struct begin                                                                \
-    {                                                                           \
-        typedef BOOST_FUSION_ITERATOR_NAME(NAME)<boost_fusion_detail_Sq, 0>     \
-             type;                                                              \
-                                                                                \
-        static type call(boost_fusion_detail_Sq& sq)                            \
-        {                                                                       \
-            return type(sq);                                                    \
-        }                                                                       \
-    };                                                                          \
-                                                                                \
-    template <typename boost_fusion_detail_Sq>                                  \
-    struct end                                                                  \
-    {                                                                           \
-        typedef BOOST_FUSION_ITERATOR_NAME(NAME)<                               \
-            boost_fusion_detail_Sq,                                             \
-            ATTRIBUTES_SEQ_SIZE                                                 \
-        > type;                                                                 \
-                                                                                \
-        static type call(boost_fusion_detail_Sq& sq)                            \
-        {                                                                       \
-            return type(sq);                                                    \
-        }                                                                       \
-    };                                                                          \
-                                                                                \
-    template <typename boost_fusion_detail_Sq>                                  \
-    struct size : boost::mpl::int_<ATTRIBUTES_SEQ_SIZE>                         \
-    {                                                                           \
-    };                                                                          \
-                                                                                \
-    template <typename boost_fusion_detail_Sq>                                  \
-    struct empty : boost::mpl::bool_<ATTRIBUTES_SEQ_SIZE == 0>                  \
-    {                                                                           \
-    };                                                                          \
-                                                                                \
-    template <                                                                  \
-        typename boost_fusion_detail_Sq,                                        \
-        typename boost_fusion_detail_N                                          \
-    >                                                                           \
-    struct value_at : value_at<                                                 \
-                          boost_fusion_detail_Sq,                               \
-                          boost::mpl::int_<boost_fusion_detail_N::value>        \
-                      >                                                         \
-    {                                                                           \
-    };                                                                          \
-                                                                                \
-    BOOST_PP_REPEAT(                                                            \
-        ATTRIBUTES_SEQ_SIZE,                                                    \
-        BOOST_FUSION_MAKE_VALUE_AT_SPECS,                                       \
-        ~)                                                                      \
-                                                                                \
-    template <                                                                  \
-        typename boost_fusion_detail_Sq,                                        \
-        typename boost_fusion_detail_N                                          \
-    >                                                                           \
-    struct at : at<                                                             \
-                    boost_fusion_detail_Sq,                                     \
-                    boost::mpl::int_<boost_fusion_detail_N::value>              \
-                >                                                               \
-    {                                                                           \
-    };                                                                          \
-                                                                                \
-    BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_MAKE_AT_SPECS, ~, ATTRIBUTES_SEQ)      \
-                                                                                \
-    BOOST_PP_SEQ_FOR_EACH_I(BOOST_FUSION_MAKE_TYPEDEF, ~, ATTRIBUTES_SEQ)       \
-                                                                                \
-    BOOST_PP_SEQ_FOR_EACH_I(                                                    \
-        BOOST_FUSION_MAKE_DATA_MEMBER,                                          \
-        ~,                                                                      \
-        ATTRIBUTES_SEQ)
-
-#endif

include/boost/fusion/algorithm/auxiliary/copy.hpp

@@ -11,11 +11,8 @@
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
 #include <boost/config.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/ice.hpp>
 
 #if defined (BOOST_MSVC)
 #  pragma warning(push)
@@ -57,19 +54,11 @@ namespace boost { namespace fusion
     }
 
     template <typename Seq1, typename Seq2>
-    inline
-    typename
-        enable_if_c<
-            type_traits::ice_and<
-                traits::is_sequence<Seq1>::value
-              , traits::is_sequence<Seq2>::value
-            >::value,
-            void
-        >::type
+    inline void
     copy(Seq1 const& src, Seq2& dest)
     {
         BOOST_STATIC_ASSERT(
-            result_of::size<Seq1>::value <= result_of::size<Seq2>::value);
+            result_of::size<Seq1>::value == result_of::size<Seq2>::value);
 
         detail::sequence_copy<
             Seq1 const, Seq2>::

include/boost/fusion/algorithm/auxiliary/move.hpp

@@ -1,84 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2013 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#if !defined(FUSION_MOVE_01192013_2225)
-#define FUSION_MOVE_01192013_2225
-
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/sequence/intrinsic/size.hpp>
-#include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/ice.hpp>
-
-#if defined (BOOST_MSVC)
-#  pragma warning(push)
-#  pragma warning (disable: 4100) // unreferenced formal parameter
-#endif
-
-namespace boost { namespace fusion
-{
-    namespace detail
-    {
-        template <typename Seq1, typename Seq2>
-        struct sequence_move
-        {
-            typedef typename result_of::end<Seq1>::type end1_type;
-            typedef typename result_of::end<Seq2>::type end2_type;
-
-            template <typename I1, typename I2>
-            static void
-            call(I1 const&, I2 const&, mpl::true_)
-            {
-            }
-
-            template <typename I1, typename I2>
-            static void
-            call(I1 const& src, I2 const& dest, mpl::false_)
-            {
-                *dest = std::move(*src);
-                call(fusion::next(src), fusion::next(dest));
-            }
-
-            template <typename I1, typename I2>
-            static void
-            call(I1 const& src, I2 const& dest)
-            {
-                typename result_of::equal_to<I1, end1_type>::type eq;
-                return call(src, dest, eq);
-            }
-        };
-    }
-
-    template <typename Seq1, typename Seq2>
-    inline
-    typename
-        enable_if_c<
-            type_traits::ice_and<
-                traits::is_sequence<Seq1>::value
-              , traits::is_sequence<Seq2>::value
-            >::value,
-            void
-        >::type
-    move(Seq1&& src, Seq2& dest)
-    {
-        BOOST_STATIC_ASSERT(
-            result_of::size<Seq1>::value <= result_of::size<Seq2>::value);
-
-        detail::sequence_move<
-            Seq1, Seq2>::
-            call(fusion::begin(src), fusion::begin(dest));
-    }
-}}
-
-#if defined (BOOST_MSVC)
-#  pragma warning(pop)
-#endif
-
-#endif

include/boost/fusion/algorithm/iteration/accumulate.hpp

@@ -9,8 +9,6 @@
 
 #include <boost/fusion/algorithm/iteration/accumulate_fwd.hpp>
 #include <boost/fusion/algorithm/iteration/fold.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -25,24 +23,14 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename State, typename F>
-    inline 
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence, State const, F>
-        >::type
+    inline typename result_of::accumulate<Sequence, State const, F>::type
     accumulate(Sequence& seq, State const& state, F f)
     {
         return fusion::fold(seq, state, f);
     }
 
     template <typename Sequence, typename State, typename F>
-    inline 
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence const, State const, F>
-        >::type
+    inline typename result_of::accumulate<Sequence const, State const, F>::type
     accumulate(Sequence const& seq, State const& state, F f)
     {
         return fusion::fold(seq, state, f);

include/boost/fusion/algorithm/iteration/accumulate_fwd.hpp

@@ -7,9 +7,6 @@
 #if !defined(BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED)
 #define BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED
 
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
-
 namespace boost { namespace fusion
 {
     namespace result_of
@@ -19,19 +16,11 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename State, typename F>
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence, State const, F>
-        >::type
+    typename result_of::accumulate<Sequence, State const, F>::type
     accumulate(Sequence& seq, State const& state, F f);
 
     template <typename Sequence, typename State, typename F>
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::accumulate<Sequence const, State const, F>
-        >::type
+    typename result_of::accumulate<Sequence const, State const, F>::type
     accumulate(Sequence const& seq, State const& state, F f);
 }}
 

include/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp

@@ -116,7 +116,7 @@ namespace boost { namespace fusion
         {
             template<typename State, typename It0, typename F>
             static Result
-            call(State const& state,It0 const&, F)
+            call(State const& state,It0 const& it0, F)
             {
                 return static_cast<Result>(state);
             }

include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp

@@ -115,7 +115,7 @@ namespace boost { namespace fusion
         {
             template<typename State, typename It0, typename F>
             static Result
-            call(State const& state,It0 const&, F)
+            call(State const& state,It0 const& it0, F)
             {
                 return static_cast<Result>(state);
             }

include/boost/fusion/algorithm/iteration/for_each.hpp

@@ -11,8 +11,6 @@
 #include <boost/fusion/algorithm/iteration/detail/for_each.hpp>
 #include <boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp>
 #include <boost/fusion/support/is_segmented.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -26,24 +24,14 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F>
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
+    inline void
     for_each(Sequence& seq, F const& f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
     }
 
     template <typename Sequence, typename F>
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
+    inline void
     for_each(Sequence const& seq, F const& f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());

include/boost/fusion/algorithm/iteration/for_each_fwd.hpp

@@ -7,9 +7,6 @@
 #if !defined(BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED)
 #define BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED
 
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
-
 namespace boost { namespace fusion
 {
     namespace result_of
@@ -19,21 +16,11 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F>
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
+    void
     for_each(Sequence& seq, F const& f);
 
     template <typename Sequence, typename F>
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , void
-        >::type
+    void
     for_each(Sequence const& seq, F const& f);
 }}
 

include/boost/fusion/algorithm/query/count.hpp

@@ -10,8 +10,6 @@
 
 #include <boost/fusion/algorithm/query/count_if.hpp>
 #include <boost/fusion/algorithm/query/detail/count.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -25,12 +23,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename T>
-    inline
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , int
-        >::type
+    inline int
     count(Sequence const& seq, T const& x)
     {
         detail::count_compare<T> f(x);

include/boost/fusion/algorithm/query/count_if.hpp

@@ -10,8 +10,6 @@
 
 #include <boost/fusion/algorithm/query/detail/count_if.hpp>
 #include <boost/fusion/support/category_of.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -25,12 +23,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F>
-    inline 
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , int
-        >::type
+    inline int
     count_if(Sequence const& seq, F f)
     {
         return detail::count_if(

include/boost/fusion/algorithm/query/detail/any.hpp

@@ -109,7 +109,7 @@ namespace detail
     struct unrolled_any<0>
     {
         template <typename It, typename F>
-        static bool call(It const&, F)
+        static bool call(It const& it, F f)
         {
             return false;
         }

include/boost/fusion/algorithm/transformation/erase.hpp

@@ -16,9 +16,6 @@
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/mpl/if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -56,38 +53,18 @@ namespace boost { namespace fusion
             }
         };
 
-        struct use_default;
-        
-        template <class T, class Default>
-        struct fusion_default_help
-          : mpl::if_<
-                is_same<T, use_default>
-              , Default
-              , T
-            >
-        {
-        };
-        
         template <
             typename Sequence
           , typename First
-          , typename Last = use_default>
+          , typename Last = typename compute_erase_last<Sequence, First>::type>
         struct erase
         {
             typedef typename result_of::begin<Sequence>::type seq_first_type;
             typedef typename result_of::end<Sequence>::type seq_last_type;
             BOOST_STATIC_ASSERT((!result_of::equal_to<seq_first_type, seq_last_type>::value));
 
-            typedef First FirstType;
-            typedef typename 
-                fusion_default_help<
-                    Last 
-                  , typename compute_erase_last<Sequence, First>::type
-                >::type
-            LastType;
-            
-            typedef typename convert_iterator<FirstType>::type first_type;
-            typedef typename convert_iterator<LastType>::type last_type;
+            typedef typename convert_iterator<First>::type first_type;
+            typedef typename convert_iterator<Last>::type last_type;
             typedef iterator_range<seq_first_type, first_type> left_type;
             typedef iterator_range<last_type, seq_last_type> right_type;
             typedef joint_view<left_type, right_type> type;
@@ -95,11 +72,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename First>
-    typename 
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , typename result_of::erase<Sequence const, First> 
-        >::type
+    typename result_of::erase<Sequence const, First>::type
     erase(Sequence const& seq, First const& first)
     {
         typedef result_of::erase<Sequence const, First> result_of;

include/boost/fusion/algorithm/transformation/insert.hpp

@@ -16,8 +16,6 @@
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/end.hpp>
 #include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -40,12 +38,8 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename Position, typename T>
-    inline 
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::insert<Sequence const, Position, T>
-        >::type
+    inline typename result_of::insert<
+        Sequence const, Position, T>::type
     insert(Sequence const& seq, Position const& pos, T const& x)
     {
         typedef result_of::insert<

include/boost/fusion/algorithm/transformation/push_back.hpp

@@ -10,8 +10,6 @@
 #include <boost/fusion/support/detail/as_fusion_element.hpp>
 #include <boost/fusion/view/joint_view/joint_view.hpp>
 #include <boost/fusion/view/single_view/single_view.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -26,12 +24,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename T>
-    inline 
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::push_back<Sequence const, T>
-        >::type
+    inline typename result_of::push_back<Sequence const, T>::type
     push_back(Sequence const& seq, T const& x)
     {
         typedef typename result_of::push_back<Sequence const, T> push_back;

include/boost/fusion/algorithm/transformation/push_front.hpp

@@ -10,8 +10,6 @@
 #include <boost/fusion/support/detail/as_fusion_element.hpp>
 #include <boost/fusion/view/joint_view/joint_view.hpp>
 #include <boost/fusion/view/single_view/single_view.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -26,12 +24,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename T>
-    inline 
-    typename
-        lazy_enable_if<
-            traits::is_sequence<Sequence>
-          , result_of::push_front<Sequence const, T>
-        >::type
+    inline typename result_of::push_front<Sequence const, T>::type
     push_front(Sequence const& seq, T const& x)
     {
         typedef typename result_of::push_front<Sequence const, T> push_front;

include/boost/fusion/algorithm/transformation/replace.hpp

@@ -9,8 +9,6 @@
 
 #include <boost/fusion/view/transform_view/transform_view.hpp>
 #include <boost/fusion/algorithm/transformation/detail/replace.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -24,12 +22,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename T>
-    inline 
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , typename result_of::replace<Sequence const, T>::type
-        >::type
+    inline typename result_of::replace<Sequence const, T>::type
     replace(Sequence const& seq, T const& old_value, T const& new_value)
     {
         typedef typename result_of::replace<Sequence const, T>::type result;

include/boost/fusion/algorithm/transformation/replace_if.hpp

@@ -9,7 +9,6 @@
 
 #include <boost/fusion/view/transform_view/transform_view.hpp>
 #include <boost/fusion/algorithm/transformation/detail/replace_if.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 
@@ -25,12 +24,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F, typename T>
-    inline 
-    typename 
-        enable_if<
-            traits::is_sequence<Sequence>
-          , typename result_of::replace_if<Sequence const, F, T>::type
-        >::type
+    inline typename result_of::replace_if<Sequence const, F, T>::type
     replace_if(Sequence const& seq, F pred, T const& new_value)
     {
         typedef typename result_of::replace_if<Sequence const, F, T>::type result;

include/boost/fusion/algorithm/transformation/reverse.hpp

@@ -8,8 +8,6 @@
 #define FUSION_REVERSE_07212005_1230
 
 #include <boost/fusion/view/reverse_view/reverse_view.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace fusion
 {
@@ -23,12 +21,7 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence>
-    inline 
-    typename
-        enable_if<
-            traits::is_sequence<Sequence>
-          , reverse_view<Sequence const>
-        >::type
+    inline reverse_view<Sequence const>
     reverse(Sequence const& view)
     {
         return reverse_view<Sequence const>(view);

include/boost/fusion/container/deque.hpp

@@ -8,7 +8,6 @@
 #if !defined(BOOST_FUSION_SEQUENCE_CONTAINER_DEQUE_24112006_2036)
 #define BOOST_FUSION_SEQUENCE_CONTAINER_DEQUE_24112006_2036
 
-#include <boost/fusion/container/deque/deque_fwd.hpp>
 #include <boost/fusion/container/deque/deque.hpp>
 #include <boost/fusion/container/deque/convert.hpp>
 

include/boost/fusion/container/deque/back_extended_deque.hpp

@@ -1,47 +1,36 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(BOOST_FUSION_BACK_EXTENDED_DEQUE_26112006_2209)
 #define BOOST_FUSION_BACK_EXTENDED_DEQUE_26112006_2209
 
+#include <boost/fusion/container/deque/detail/keyed_element.hpp>
 #include <boost/mpl/int.hpp>
-
+#include <boost/mpl/plus.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/support/sequence_base.hpp>
-#include <boost/fusion/container/deque/detail/keyed_element.hpp>
 
-namespace boost { namespace fusion
-{
-    template <typename Deque, typename T>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+namespace boost { namespace fusion {
+    template<typename Deque, typename T>
     struct back_extended_deque
-      : detail::keyed_element<typename Deque::next_up, T, Deque>
-      , sequence_base<back_extended_deque<Deque, T> >
+        : detail::keyed_element<typename Deque::next_up, T, Deque>,
+          sequence_base<back_extended_deque<Deque, T> >
     {
         typedef detail::keyed_element<typename Deque::next_up, T, Deque> base;
         typedef typename Deque::next_down next_down;
-        typedef mpl::int_<(Deque::next_up::value + 1)> next_up;
-        typedef mpl::int_<(result_of::size<Deque>::value + 1)> size;
+        typedef mpl::int_<mpl::plus<typename Deque::next_up, mpl::int_<1> >::value> next_up;
+        typedef mpl::plus<typename result_of::size<Deque>::type, mpl::int_<1> > size;
 
-        template <typename Arg>
-        back_extended_deque(Deque const& deque, Arg const& val)
-          : base(val, deque)
+        back_extended_deque(Deque const& deque, typename add_reference<typename add_const<T>::type>::type t)
+            : base(t, deque)
         {}
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename Arg>
-        back_extended_deque(Deque const& deque, Arg& val)
-          : base(val, deque)
-        {}
-#else
-        template <typename Arg>
-        back_extended_deque(Deque const& deque, Arg&& val)
-          : base(std::forward<Arg>(val), deque)
-        {}
-#endif
     };
 }}
 

include/boost/fusion/container/deque/convert.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2013 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,32 +8,23 @@
 #if !defined(FUSION_CONVERT_20061213_2207)
 #define FUSION_CONVERT_20061213_2207
 
+#include <boost/fusion/container/deque/detail/as_deque.hpp>
 #include <boost/fusion/container/deque/detail/convert_impl.hpp>
 #include <boost/fusion/container/deque/deque.hpp>
-
-#if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-///////////////////////////////////////////////////////////////////////////////
-// C++03 (non-variadic) implementation
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/fusion/container/deque/detail/cpp03/build_deque.hpp>
-
-#else
-///////////////////////////////////////////////////////////////////////////////
-// C++11 variadic implementation
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/fusion/container/deque/detail/build_deque.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
 
 namespace boost { namespace fusion
 {
     namespace result_of
     {
         template <typename Sequence>
-        struct as_deque :
-            detail::build_deque<
-                typename result_of::begin<Sequence>::type
-              , typename result_of::end<Sequence>::type
-            >
+        struct as_deque
         {
+            typedef typename detail::as_deque<result_of::size<Sequence>::value> gen;
+            typedef typename gen::
+                template apply<typename result_of::begin<Sequence>::type>::type
+            type;
         };
     }
 
@@ -41,18 +32,17 @@ namespace boost { namespace fusion
     inline typename result_of::as_deque<Sequence>::type
     as_deque(Sequence& seq)
     {
-        typedef result_of::as_deque<Sequence> gen;
-        return gen::call(fusion::begin(seq), fusion::end(seq));
+        typedef typename result_of::as_deque<Sequence>::gen gen;
+        return gen::call(fusion::begin(seq));
     }
 
     template <typename Sequence>
     inline typename result_of::as_deque<Sequence const>::type
     as_deque(Sequence const& seq)
     {
-        typedef result_of::as_deque<Sequence const> gen;
-        return gen::call(fusion::begin(seq), fusion::end(seq));
+        typedef typename result_of::as_deque<Sequence const>::gen gen;
+        return gen::call(fusion::begin(seq));
     }
 }}
 
 #endif
-#endif

include/boost/fusion/container/deque/deque.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,23 +8,20 @@
 #if !defined(BOOST_FUSION_DEQUE_26112006_1649)
 #define BOOST_FUSION_DEQUE_26112006_1649
 
-# include <boost/fusion/container/deque/deque_fwd.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-// Without variadics, we will use the PP version
-///////////////////////////////////////////////////////////////////////////////
-#if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-# include <boost/fusion/container/deque/detail/cpp03/deque.hpp>
-#else
-
-///////////////////////////////////////////////////////////////////////////////
-// C++11 interface
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/fusion/support/sequence_base.hpp>
-#include <boost/fusion/support/detail/access.hpp>
-#include <boost/fusion/support/is_sequence.hpp>
-#include <boost/fusion/container/deque/detail/keyed_element.hpp>
+#include <boost/fusion/container/deque/limits.hpp>
+#include <boost/fusion/container/deque/front_extended_deque.hpp>
+#include <boost/fusion/container/deque/back_extended_deque.hpp>
 #include <boost/fusion/container/deque/detail/deque_keyed_values.hpp>
+#include <boost/fusion/container/deque/detail/deque_initial_size.hpp>
+#include <boost/fusion/support/sequence_base.hpp>
+#include <boost/fusion/container/deque/detail/keyed_element.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
 #include <boost/fusion/container/deque/deque_fwd.hpp>
 #include <boost/fusion/container/deque/detail/value_at_impl.hpp>
 #include <boost/fusion/container/deque/detail/at_impl.hpp>
@@ -32,129 +29,93 @@
 #include <boost/fusion/container/deque/detail/end_impl.hpp>
 #include <boost/fusion/container/deque/detail/is_sequence_impl.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/mpl/bool.hpp>
 
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/and.hpp>
+#include <boost/fusion/support/sequence_base.hpp>
+#include <boost/fusion/support/void.hpp>
 #include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_convertible.hpp>
 
-namespace boost { namespace fusion
-{
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/deque/detail/preprocessed/deque.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion {
+
     struct deque_tag;
 
-    template <typename ...Elements>
-    struct deque : detail::nil_keyed_element
+    template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>
+    struct deque
+        :
+        detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type,
+        sequence_base<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)> >
     {
         typedef deque_tag fusion_tag;
         typedef bidirectional_traversal_tag category;
-        typedef mpl::int_<0> size;
-        typedef mpl::int_<0> next_up;
-        typedef mpl::int_<0> next_down;
-        typedef mpl::false_ is_view;
-
-        template <typename Sequence>
-        deque(Sequence const&,
-            typename enable_if<
-                mpl::and_<
-                    traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence>>>::type* /*dummy*/ = 0)
-        {}
-
-        deque() {}
-    };
-
-    template <typename Head, typename ...Tail>
-    struct deque<Head, Tail...>
-      : detail::deque_keyed_values<Head, Tail...>::type
-      , sequence_base<deque<Head, Tail...>>
-    {
-        typedef deque_tag fusion_tag;
-        typedef bidirectional_traversal_tag category;
-        typedef typename detail::deque_keyed_values<Head, Tail...>::type base;
-        typedef mpl::int_<(sizeof ...(Tail) + 1)> size;
+        typedef typename detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type base;
+        typedef typename detail::deque_initial_size<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type size;
         typedef mpl::int_<size::value> next_up;
-        typedef mpl::int_<((size::value == 0) ? 0 : -1)> next_down;
+        typedef mpl::int_<
+            mpl::if_<mpl::equal_to<size, mpl::int_<0> >, mpl::int_<0>, mpl::int_<-1> >::type::value> next_down;
         typedef mpl::false_ is_view;
 
+#include <boost/fusion/container/deque/detail/deque_forward_ctor.hpp>
+
         deque()
-        {}
+            {}
 
-        template <typename ...Elements>
-        deque(deque<Elements...> const& seq)
-          : base(seq)
-        {}
+        explicit deque(typename add_reference<typename add_const<T0>::type>::type t0)
+            : base(t0, detail::nil_keyed_element())
+            {}
 
-        template <typename ...Elements>
-        deque(deque<Elements...>& seq)
-          : base(seq)
-        {}
+        template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
+            deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)> const& seq)
+            : base(seq)
+            {}
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename ...Elements>
-        deque(deque<Elements...>&& seq)
-          : base(std::forward<deque<Elements...>>(seq))
-        {}
-#endif
+        template<typename Sequence>
+            deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0)
+            : base(base::from_iterator(fusion::begin(seq)))
+            {}
 
-        deque(deque const& seq)
-          : base(seq)
-        {}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        deque(deque&& seq)
-          : base(std::forward<deque>(seq))
-        {}
-#endif
-
-        explicit deque(Head const& head, Tail const&... tail)
-          : base(detail::deque_keyed_values<Head, Tail...>::construct(head, tail...))
-        {}
-
-        template <typename Head_, typename ...Tail_>
-        explicit deque(Head_ const& head, Tail_ const&... tail)
-          : base(detail::deque_keyed_values<Head_, Tail_...>::construct(head, tail...))
-        {}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename Head_, typename ...Tail_>
-        explicit deque(Head_&& head, Tail_&&... tail)
-          : base(detail::deque_keyed_values<Head, Tail...>
-                ::forward_(std::forward<Head_>(head), std::forward<Tail_>(tail)...))
-        {}
-#endif
-
-        template <typename Sequence>
-        explicit deque(Sequence const& seq
-          , typename disable_if<is_convertible<Sequence, Head> >::type* /*dummy*/ = 0)
-          : base(base::from_iterator(fusion::begin(seq)))
-        {}
-
-        template <typename ...Elements>
-        deque& operator=(deque<Elements...> const& rhs)
+        template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
+        deque&
+        operator=(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)> const& rhs)
         {
             base::operator=(rhs);
             return *this;
         }
 
         template <typename T>
-        deque& operator=(T const& rhs)
+        deque&
+        operator=(T const& rhs)
         {
             base::operator=(rhs);
             return *this;
         }
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename T>
-        deque& operator=(T&& rhs)
-        {
-            base::operator=(std::forward<T>(rhs));
-            return *this;
-        }
-#endif
-
     };
 }}
 
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
 #endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
 #endif

include/boost/fusion/container/deque/deque_fwd.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2007 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,28 +8,43 @@
 #if !defined(FUSION_DEQUE_FORWARD_02092007_0749)
 #define FUSION_DEQUE_FORWARD_02092007_0749
 
-#include <boost/config.hpp>
+#include <boost/fusion/container/deque/limits.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
 
-///////////////////////////////////////////////////////////////////////////////
-// With no decltype and variadics, we will use the C++03 version
-///////////////////////////////////////////////////////////////////////////////
-#if (defined(BOOST_NO_CXX11_DECLTYPE)             \
-  || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)   \
-  || defined(BOOST_NO_CXX11_RVALUE_REFERENCES))
-# include <boost/fusion/container/deque/detail/cpp03/deque_fwd.hpp>
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/deque/detail/preprocessed/deque_fwd.hpp>
 #else
-# if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#   define BOOST_FUSION_HAS_VARIADIC_DEQUE
-# endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR "_fwd.hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
 
-///////////////////////////////////////////////////////////////////////////////
-// C++11 interface
-///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace fusion
 {
-    template <typename ...T>
+    struct void_;
+
+    template<
+        BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+            FUSION_MAX_DEQUE_SIZE, typename T, void_)>
     struct deque;
 }}
 
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
 #endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
 #endif

include/boost/fusion/container/deque/deque_iterator.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(BOOST_FUSION_DEQUE_ITERATOR_26112006_2154)
@@ -12,13 +12,13 @@
 #include <boost/fusion/container/deque/detail/keyed_element.hpp>
 #include <boost/mpl/minus.hpp>
 #include <boost/mpl/equal_to.hpp>
-#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_const.hpp> 
 
 namespace boost { namespace fusion {
 
     struct bidirectional_traversal_tag;
 
-    template <typename Seq, int Pos>
+    template<typename Seq, int Pos>
     struct deque_iterator
         : iterator_facade<deque_iterator<Seq, Pos>, bidirectional_traversal_tag>
     {
@@ -84,7 +84,7 @@ namespace boost { namespace fusion {
             typedef typename
                 mpl::minus<
                     typename I2::index, typename I1::index
-                >::type
+                >::type 
             type;
 
             static type

include/boost/fusion/container/deque/detail/as_deque.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -45,7 +45,7 @@ namespace boost { namespace fusion { namespace detail
 }}}
 
 #if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/as_deque.hpp>
 #else
 #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
 #pragma wave option(preserve: 2, line: 0, output: "preprocessed/as_deque" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
@@ -78,7 +78,7 @@ namespace boost { namespace fusion { namespace detail
     typedef typename fusion::result_of::value_of<BOOST_PP_CAT(I, n)>::type      \
         BOOST_PP_CAT(T, n);
 
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/deque/detail/cpp03/as_deque.hpp>
+#define BOOST_PP_FILENAME_1 <boost/fusion/container/deque/detail/as_deque.hpp>
 #define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
 #include BOOST_PP_ITERATE()
 

include/boost/fusion/container/deque/detail/at_impl.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(BOOST_FUSION_DEQUE_AT_IMPL_09122006_2017)
@@ -19,15 +19,15 @@
 #include <boost/type_traits/add_const.hpp>
 #include <boost/type_traits/add_reference.hpp>
 
-namespace boost { namespace fusion
-{
+namespace boost { namespace fusion { 
+
     struct deque_tag;
 
-    namespace extension
+    namespace extension 
     {
         template<typename T>
         struct at_impl;
-
+        
         template<>
         struct at_impl<deque_tag>
         {
@@ -37,21 +37,15 @@ namespace boost { namespace fusion
                 typedef typename Sequence::next_up next_up;
                 typedef typename Sequence::next_down next_down;
                 BOOST_MPL_ASSERT_RELATION(next_down::value, !=, next_up::value);
-
-                static int const offset = next_down::value + 1;
-                typedef mpl::int_<(N::value + offset)> adjusted_index;
-                typedef typename
-                    detail::keyed_element_value_at<Sequence, adjusted_index>::type
-                element_type;
-
-                typedef typename
-                    add_reference<
-                      typename mpl::eval_if<
-                      is_const<Sequence>,
-                      add_const<element_type>,
-                      mpl::identity<element_type> >::type
-                    >::type
-                type;
+                
+                typedef mpl::plus<next_down, mpl::int_<1> > offset;
+                typedef mpl::int_<mpl::plus<N, offset>::value> adjusted_index;
+                typedef typename detail::keyed_element_value_at<Sequence, adjusted_index>::type element_type;
+                typedef typename add_reference<
+                    typename mpl::eval_if<
+                    is_const<Sequence>,
+                    add_const<element_type>,
+                    mpl::identity<element_type> >::type>::type type;
 
                 static type call(Sequence& seq)
                 {

include/boost/fusion/container/deque/detail/begin_impl.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(BOOST_FUSION_DEQUE_BEGIN_IMPL_09122006_2034)
@@ -13,29 +13,27 @@
 #include <boost/mpl/equal_to.hpp>
 #include <boost/mpl/if.hpp>
 
-namespace boost { namespace fusion
-{
+namespace boost { namespace fusion { 
+
     struct deque_tag;
 
-    namespace extension
+    namespace extension 
     {
         template<typename T>
         struct begin_impl;
-
+        
         template<>
         struct begin_impl<deque_tag>
         {
             template<typename Sequence>
             struct apply
             {
-                typedef typename
-                    mpl::if_c<
-                        (Sequence::next_down::value == Sequence::next_up::value)
-                      , deque_iterator<Sequence, 0>
-                      , deque_iterator<Sequence, (Sequence::next_down::value + 1)>
-                    >::type
-                type;
-
+                typedef typename mpl::if_<
+                    mpl::equal_to<typename Sequence::next_down, typename Sequence::next_up>,
+                    deque_iterator<Sequence, 0>,
+                    deque_iterator<
+                    Sequence, mpl::plus<typename Sequence::next_down, mpl::int_<1> >::value> >::type type;
+                
                 static type call(Sequence& seq)
                 {
                     return type(seq);

include/boost/fusion/container/deque/detail/build_deque.hpp

@@ -1,74 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2005-2013 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#if !defined(BOOST_FUSION_BUILD_DEQUE_02032013_1921)
-#define BOOST_FUSION_BUILD_DEQUE_02032013_1921
-
-#include <boost/fusion/iterator/equal_to.hpp>
-#include <boost/fusion/iterator/next.hpp>
-#include <boost/fusion/iterator/value_of.hpp>
-#include <boost/fusion/iterator/deref.hpp>
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/end.hpp>
-#include <boost/fusion/container/deque/front_extended_deque.hpp>
-
-namespace boost { namespace fusion { namespace detail
-{
-    template <typename First, typename Last
-      , bool is_empty = result_of::equal_to<First, Last>::value>
-    struct build_deque;
-
-    template <typename First, typename Last>
-    struct build_deque<First, Last, true>
-    {
-        typedef deque<> type;
-        static type
-        call(First const&, Last const&)
-        {
-            return type();
-        }
-    };
-
-    template <typename T, typename Rest>
-    struct push_front_deque;
-
-    template <typename T, typename ...Rest>
-    struct push_front_deque<T, deque<Rest...>>
-    {
-        typedef deque<T, Rest...> type;
-
-        static type
-        call(T const& first, deque<Rest...> const& rest)
-        {
-            return type(front_extended_deque<deque<Rest...>, T>(rest, first));
-        }
-    };
-
-    template <typename First, typename Last>
-    struct build_deque<First, Last, false>
-    {
-        typedef
-            build_deque<typename result_of::next<First>::type, Last>
-        next_build_deque;
-
-        typedef push_front_deque<
-            typename result_of::value_of<First>::type
-          , typename next_build_deque::type>
-        push_front;
-
-        typedef typename push_front::type type;
-
-        static type
-        call(First const& f, Last const& l)
-        {
-            typename result_of::value_of<First>::type v = *f;
-            return push_front::call(
-                v, next_build_deque::call(fusion::next(f), l));
-        }
-    };
-}}}
-
-#endif

include/boost/fusion/container/deque/detail/convert_impl.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,7 +8,7 @@
 #if !defined(FUSION_CONVERT_IMPL_20061213_2207)
 #define FUSION_CONVERT_IMPL_20061213_2207
 
-#include <boost/fusion/container/deque/convert.hpp>
+#include <boost/fusion/container/deque/detail/as_deque.hpp>
 #include <boost/fusion/container/deque/deque.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
@@ -17,12 +17,6 @@ namespace boost { namespace fusion
 {
     struct deque_tag;
 
-    namespace result_of
-    {
-        template <typename Sequence>
-        struct as_deque;
-    }
-
     namespace extension
     {
         template <typename T>
@@ -34,11 +28,14 @@ namespace boost { namespace fusion
             template <typename Sequence>
             struct apply
             {
-                typedef result_of::as_deque<Sequence> gen;
-                typedef typename gen::type type;
+                typedef typename detail::as_deque<result_of::size<Sequence>::value> gen;
+                typedef typename gen::
+                    template apply<typename result_of::begin<Sequence>::type>::type
+                type;
+
                 static type call(Sequence& seq)
                 {
-                    return gen::call(seq);
+                    return gen::call(fusion::begin(seq));
                 }
             };
         };

include/boost/fusion/container/deque/detail/cpp03/build_deque.hpp

@@ -1,52 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2005-2013 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#if !defined(BOOST_FUSION_BUILD_DEQUE_02032013_1921)
-#define BOOST_FUSION_BUILD_DEQUE_02032013_1921
-
-#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#error "C++03 only! This file should not have been included"
-#endif
-
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/size.hpp>
-#include <boost/fusion/container/deque/detail/cpp03/as_deque.hpp>
-#include <boost/fusion/container/deque/front_extended_deque.hpp>
-
-namespace boost { namespace fusion
-{
-    namespace result_of
-    {
-        template <typename Sequence>
-        struct as_deque
-        {
-            typedef typename
-                detail::as_deque<result_of::size<Sequence>::value>
-            gen;
-            typedef typename gen::
-                template apply<typename result_of::begin<Sequence>::type>::type
-            type;
-        };
-    }
-
-    template <typename Sequence>
-    inline typename result_of::as_deque<Sequence>::type
-    as_deque(Sequence& seq)
-    {
-        typedef typename result_of::as_deque<Sequence>::gen gen;
-        return gen::call(fusion::begin(seq));
-    }
-
-    template <typename Sequence>
-    inline typename result_of::as_deque<Sequence const>::type
-    as_deque(Sequence const& seq)
-    {
-        typedef typename result_of::as_deque<Sequence const>::gen gen;
-        return gen::call(fusion::begin(seq));
-    }
-}}
-
-#endif

include/boost/fusion/container/deque/detail/cpp03/deque.hpp

@@ -1,181 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#if !defined(BOOST_PP_FUSION_DEQUE_26112006_1649)
-#define BOOST_PP_FUSION_DEQUE_26112006_1649
-
-#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#error "C++03 only! This file should not have been included"
-#endif
-
-#include <boost/fusion/container/deque/detail/cpp03/limits.hpp>
-#include <boost/fusion/container/deque/front_extended_deque.hpp>
-#include <boost/fusion/container/deque/back_extended_deque.hpp>
-#include <boost/fusion/container/deque/detail/cpp03/deque_keyed_values.hpp>
-#include <boost/fusion/container/deque/detail/cpp03/deque_initial_size.hpp>
-#include <boost/fusion/support/sequence_base.hpp>
-#include <boost/fusion/container/deque/detail/keyed_element.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-
-#include <boost/fusion/container/deque/deque_fwd.hpp>
-#include <boost/fusion/container/deque/detail/value_at_impl.hpp>
-#include <boost/fusion/container/deque/detail/at_impl.hpp>
-#include <boost/fusion/container/deque/detail/begin_impl.hpp>
-#include <boost/fusion/container/deque/detail/end_impl.hpp>
-#include <boost/fusion/container/deque/detail/is_sequence_impl.hpp>
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/mpl/bool.hpp>
-
-#include <boost/fusion/support/sequence_base.hpp>
-#include <boost/fusion/support/void.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque.hpp>
-#else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
-#endif
-
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
-
-namespace boost { namespace fusion {
-
-    struct deque_tag;
-
-    template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>
-    struct deque
-        :
-        detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type,
-        sequence_base<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)> >
-    {
-        typedef deque_tag fusion_tag;
-        typedef bidirectional_traversal_tag category;
-        typedef typename detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type base;
-        typedef typename detail::deque_initial_size<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type size;
-        typedef mpl::int_<size::value> next_up;
-        typedef mpl::int_<
-            mpl::if_<mpl::equal_to<size, mpl::int_<0> >, mpl::int_<0>, mpl::int_<-1> >::type::value> next_down;
-        typedef mpl::false_ is_view;
-
-#include <boost/fusion/container/deque/detail/cpp03/deque_forward_ctor.hpp>
-
-        deque()
-            {}
-
-        explicit deque(typename add_reference<typename add_const<T0>::type>::type t0)
-            : base(t0, detail::nil_keyed_element())
-            {}
-
-        explicit deque(deque const& rhs)
-            : base(rhs)
-            {}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename T0_>
-        explicit deque(T0_&& t0
-          , typename enable_if<is_convertible<T0_, T0> >::type* /*dummy*/ = 0
-         )
-            : base(std::forward<T0_>(t0), detail::nil_keyed_element())
-            {}
-
-        explicit deque(deque&& rhs)
-            : base(std::forward<deque>(rhs))
-            {}
-#endif
-
-        template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
-        deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)> const& seq)
-            : base(seq)
-            {}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
-        deque(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>&& seq)
-            : base(std::forward<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)>>(seq))
-            {}
-#endif
-
-        template<typename Sequence>
-        deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0)
-            : base(base::from_iterator(fusion::begin(seq)))
-            {}
-
-        template <BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename U)>
-        deque&
-        operator=(deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, U)> const& rhs)
-        {
-            base::operator=(rhs);
-            return *this;
-        }
-
-        template <typename T>
-        deque&
-        operator=(T const& rhs)
-        {
-            base::operator=(rhs);
-            return *this;
-        }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename T>
-        deque&
-        operator=(T&& rhs)
-        {
-            base::operator=(std::forward<T>(rhs));
-            return *this;
-        }
-#endif
-
-    };
-
-    template <>
-    struct deque<> : detail::nil_keyed_element
-    {
-        typedef deque_tag fusion_tag;
-        typedef bidirectional_traversal_tag category;
-        typedef mpl::int_<0> size;
-        typedef mpl::int_<0> next_up;
-        typedef mpl::int_<0> next_down;
-        typedef mpl::false_ is_view;
-
-        template <typename Sequence>
-        deque(Sequence const&,
-            typename enable_if<
-                mpl::and_<
-                    traits::is_sequence<Sequence>
-                  , result_of::empty<Sequence> > >::type* /*dummy*/ = 0)
-        {}
-
-        deque() {}
-    };
-
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#endif

include/boost/fusion/container/deque/detail/cpp03/deque_fwd.hpp

@@ -1,54 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
-    Copyright (c) 2005-2007 Dan Marsden
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#if !defined(FUSION_PP_DEQUE_FORWARD_02092007_0749)
-#define FUSION_PP_DEQUE_FORWARD_02092007_0749
-
-#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#error "C++03 only! This file should not have been included"
-#endif
-
-#include <boost/fusion/container/deque/detail/cpp03/limits.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_fwd.hpp>
-#else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque" FUSION_MAX_DEQUE_SIZE_STR "_fwd.hpp")
-#endif
-
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
-
-namespace boost { namespace fusion
-{
-    struct void_;
-
-    template<
-        BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-            FUSION_MAX_DEQUE_SIZE, typename T, void_)>
-    struct deque;
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#endif

include/boost/fusion/container/deque/detail/cpp03/deque_keyed_values.hpp

@@ -1,111 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330)
-#define BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330
-
-#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#error "C++03 only! This file should not have been included"
-#endif
-
-#include <boost/fusion/container/deque/detail/cpp03/limits.hpp>
-#include <boost/fusion/container/deque/detail/keyed_element.hpp>
-
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/type_traits/add_reference.hpp>
-
-#include <boost/mpl/plus.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/print.hpp>
-
-#define FUSION_VOID(z, n, _) void_
-
-namespace boost { namespace fusion
-{
-    struct void_;
-}}
-
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values.hpp>
-#else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque_keyed_values" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
-#endif
-
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
-
-namespace boost { namespace fusion { namespace detail
-{
-    template<typename Key, typename Value, typename Rest>
-    struct keyed_element;
-
-    struct nil_keyed_element;
-
-    template<typename N, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
-    struct deque_keyed_values_impl;
-
-    template<typename N>
-    struct deque_keyed_values_impl<N, BOOST_PP_ENUM(FUSION_MAX_DEQUE_SIZE, FUSION_VOID, _)>
-    {
-        typedef nil_keyed_element type;
-
-        static type construct()
-        {
-            return type();
-        }
-
-        static type forward_()
-        {
-            return type();
-        }
-    };
-
-    template<typename N, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>
-    struct deque_keyed_values_impl
-    {
-        typedef mpl::int_<mpl::plus<N, mpl::int_<1> >::value> next_index;
-
-        typedef typename deque_keyed_values_impl<
-            next_index,
-            BOOST_PP_ENUM_SHIFTED_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type tail;
-        typedef keyed_element<N, T0, tail> type;
-
-#include <boost/fusion/container/deque/detail/cpp03/deque_keyed_values_call.hpp>
-
-    };
-
-    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
-    struct deque_keyed_values
-        : deque_keyed_values_impl<mpl::int_<0>, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>
-    {};
-
-}}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#undef FUSION_VOID
-
-#endif

include/boost/fusion/container/deque/detail/cpp03/deque_keyed_values_call.hpp

@@ -1,61 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
-    Copyright (c) 2005-2006 Dan Marsden
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#if !defined(BOOST_PP_IS_ITERATING)
-#if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211)
-#define BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211
-
-#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#error "C++03 only! This file should not have been included"
-#endif
-
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
-#include <boost/preprocessor/repetition/enum_shifted.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-
-#define FUSION_DEQUE_KEYED_VALUES_FORWARD(z, n, _)    \
-   std::forward<BOOST_PP_CAT(T_, n)>(BOOST_PP_CAT(t, n))
-
-#define BOOST_PP_FILENAME_1 \
-    <boost/fusion/container/deque/detail/cpp03/deque_keyed_values_call.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef FUSION_DEQUE_KEYED_VALUES_FORWARD
-#endif
-#else
-
-#define N BOOST_PP_ITERATION()
-
-        static type construct(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t))
-        {
-            return type(t0,
-                        deque_keyed_values_impl<
-                        next_index
-        #if N > 1
-                        , BOOST_PP_ENUM_SHIFTED_PARAMS(N, T)
-        #endif
-                        >::construct(BOOST_PP_ENUM_SHIFTED_PARAMS(N, t)));
-        }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <BOOST_PP_ENUM_PARAMS(N, typename T_)>
-        static type forward_(BOOST_PP_ENUM_BINARY_PARAMS(N, T_, && t))
-        {
-            return type(std::forward<T_0>(t0),
-                        deque_keyed_values_impl<
-                        next_index
-        #if N > 1
-                        , BOOST_PP_ENUM_SHIFTED_PARAMS(N, T_)
-        #endif
-                        >::forward_(BOOST_PP_ENUM_SHIFTED(N, FUSION_DEQUE_KEYED_VALUES_FORWARD, _)));
-        }
-#endif
-
-#undef N
-#endif

include/boost/fusion/container/deque/detail/deque_forward_ctor.hpp

@@ -1,52 +1,31 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(BOOST_PP_IS_ITERATING)
 #if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_FORWARD_CTOR_04122006_2212)
 #define BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_FORWARD_CTOR_04122006_2212
 
-#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#error "C++03 only! This file should not have been included"
-#endif
-
-#define FUSION_DEQUE_FORWARD_CTOR_FORWARD(z, n, _)    std::forward<T_##n>(t##n)
-
 #include <boost/preprocessor/iterate.hpp>
 #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
 #include <boost/preprocessor/repetition/enum_binary_params.hpp>
 
 #define BOOST_PP_FILENAME_1 \
-    <boost/fusion/container/deque/detail/cpp03/deque_forward_ctor.hpp>
+    <boost/fusion/container/deque/detail/deque_forward_ctor.hpp>
 #define BOOST_PP_ITERATION_LIMITS (2, FUSION_MAX_DEQUE_SIZE)
 #include BOOST_PP_ITERATE()
 
-#undef FUSION_DEQUE_FORWARD_CTOR_FORWARD
 #endif
 #else
 
 #define N BOOST_PP_ITERATION()
 
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 deque(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t))
-    : base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::construct(BOOST_PP_ENUM_PARAMS(N, t)))
+    : base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::call(BOOST_PP_ENUM_PARAMS(N, t)))
 {}
 
-#else
-
-deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& t))
-    : base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::construct(BOOST_PP_ENUM_PARAMS(N, t)))
-{}
-
-template <BOOST_PP_ENUM_PARAMS(N, typename T_)>
-deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T_, && t))
-    : base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::
-      forward_(BOOST_PP_ENUM(N, FUSION_DEQUE_FORWARD_CTOR_FORWARD, _)))
-{}
-#endif
-
 #undef N
 #endif

include/boost/fusion/container/deque/detail/deque_initial_size.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,10 +8,6 @@
 #if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139)
 #define BOOST_FUSION_DEQUE_DETAIL_DEQUE_INITIAL_SIZE_26112006_2139
 
-#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#error "C++03 only! This file should not have been included"
-#endif
-
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/mpl/find.hpp>
 #include <boost/mpl/begin.hpp>
@@ -25,7 +21,7 @@ namespace boost { namespace fusion
 }}
 
 #if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size.hpp>
 #else
 #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
 #pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque_initial_size" FUSION_MAX_DEQUE_SIZE_STR ".hpp")

include/boost/fusion/container/deque/detail/deque_keyed_values.hpp

@@ -1,67 +1,102 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
-#if !defined(BOOST_FUSION_DEQUE_DETAIL_CPP11_DEQUE_KEYED_VALUES_07042012_1901)
-#define BOOST_FUSION_DEQUE_DETAIL_CPP11_DEQUE_KEYED_VALUES_07042012_1901
+#if !defined(BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330)
+#define BOOST_FUSION_DEQUE_DETAIL_DEQUE_KEYED_VALUES_26112006_1330
 
+#include <boost/fusion/container/deque/limits.hpp>
 #include <boost/fusion/container/deque/detail/keyed_element.hpp>
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/add_const.hpp>
+
+#include <boost/mpl/plus.hpp>
 #include <boost/mpl/int.hpp>
+#include <boost/mpl/print.hpp>
+
+#define FUSION_VOID(z, n, _) void_
+
+namespace boost { namespace fusion
+{
+    struct void_;
+}}
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "preprocessed/deque_keyed_values" FUSION_MAX_DEQUE_SIZE_STR ".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
 
 namespace boost { namespace fusion { namespace detail
 {
     template<typename Key, typename Value, typename Rest>
     struct keyed_element;
 
-    template <typename N, typename ...Elements>
-    struct deque_keyed_values_impl;
-
-    template <typename N, typename Head, typename ...Tail>
-    struct deque_keyed_values_impl<N, Head, Tail...>
-    {
-        typedef mpl::int_<(N::value + 1)> next_index;
-        typedef typename deque_keyed_values_impl<next_index, Tail...>::type tail;
-        typedef keyed_element<N, Head, tail> type;
-
-        static type construct(
-          typename detail::call_param<Head>::type head
-        , typename detail::call_param<Tail>::type... tail)
-        {
-            return type(
-                head
-              , deque_keyed_values_impl<next_index, Tail...>::construct(tail...)
-            );
-        }
-
-        template <typename Head_, typename ...Tail_>
-        static type forward_(Head_&& head, Tail_&&... tail)
-        {
-            return type(
-                std::forward<Head_>(head)
-              , deque_keyed_values_impl<next_index, Tail_...>::
-                  forward_(std::forward<Tail_>(tail)...)
-            );
-        }
-    };
-
     struct nil_keyed_element;
 
-    template <typename N>
-    struct deque_keyed_values_impl<N>
+    template<typename N, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
+    struct deque_keyed_values_impl;
+
+    template<typename N>
+    struct deque_keyed_values_impl<N, BOOST_PP_ENUM(FUSION_MAX_DEQUE_SIZE, FUSION_VOID, _)>
     {
         typedef nil_keyed_element type;
-        static type construct() { return type(); }
-        static type forward_() { return type(); }
+
+        static type call()
+        {
+            return type();
+        }
     };
 
-    template <typename ...Elements>
+    template<typename N, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>
+    struct deque_keyed_values_impl
+    {
+        typedef mpl::int_<mpl::plus<N, mpl::int_<1> >::value> next_index;
+
+        typedef typename deque_keyed_values_impl<
+            next_index,
+            BOOST_PP_ENUM_SHIFTED_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type tail;
+        typedef keyed_element<N, T0, tail> type;
+
+#include <boost/fusion/container/deque/detail/deque_keyed_values_call.hpp>
+
+    };
+
+    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
     struct deque_keyed_values
-      : deque_keyed_values_impl<mpl::int_<0>, Elements...> {};
+        : deque_keyed_values_impl<mpl::int_<0>, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>
+    {};
+
 }}}
 
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#undef FUSION_VOID
+
 #endif

include/boost/fusion/container/deque/detail/deque_keyed_values_call.hpp

@@ -0,0 +1,38 @@
+/*=============================================================================
+    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#if !defined(BOOST_PP_IS_ITERATING)
+#if !defined(BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211)
+#define BOOST_FUSION_SEQUENCE_DEQUE_DETAIL_DEQUE_KEYED_VALUES_CALL_04122006_2211
+
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+
+#define BOOST_PP_FILENAME_1 \
+    <boost/fusion/container/deque/detail/deque_keyed_values_call.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
+#include BOOST_PP_ITERATE()
+
+#endif
+#else
+
+#define N BOOST_PP_ITERATION()
+
+        static type call(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<typename add_const<T, >::type>::type t))
+        {
+            return type(t0,
+                        deque_keyed_values_impl<
+                        next_index
+        #if N > 1
+                        , BOOST_PP_ENUM_SHIFTED_PARAMS(N, T)
+        #endif
+                        >::call(BOOST_PP_ENUM_SHIFTED_PARAMS(N, t)));
+        }
+
+#undef N
+#endif

include/boost/fusion/container/deque/detail/end_impl.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(BOOST_FUSION_DEQUE_END_IMPL_09122006_2034)
@@ -13,29 +13,27 @@
 #include <boost/mpl/equal_to.hpp>
 #include <boost/mpl/if.hpp>
 
-namespace boost { namespace fusion
-{
+namespace boost { namespace fusion { 
+
     struct deque_tag;
 
-    namespace extension
+    namespace extension 
     {
         template<typename T>
         struct end_impl;
-
+        
         template<>
         struct end_impl<deque_tag>
         {
             template<typename Sequence>
             struct apply
             {
-                typedef typename
-                    mpl::if_c<
-                        (Sequence::next_down::value == Sequence::next_up::value)
-                      , deque_iterator<Sequence, 0>
-                      , deque_iterator<Sequence, Sequence::next_up::value>
-                    >::type
-                type;
-
+                typedef typename mpl::if_<
+                    mpl::equal_to<typename Sequence::next_down, typename Sequence::next_up>,
+                    deque_iterator<Sequence, 0>,
+                    deque_iterator<
+                    Sequence, Sequence::next_up::value> >::type type;
+                
                 static type call(Sequence& seq)
                 {
                     return type(seq);

include/boost/fusion/container/deque/detail/is_sequence_impl.hpp

@@ -1,7 +1,7 @@
 /*=============================================================================
     Copyright (c) 2010 Christopher Schmidt
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
@@ -14,16 +14,18 @@ namespace boost { namespace fusion
 {
     struct deque_tag;
 
-    namespace extension
+    namespace extension 
     {
         template<typename T>
         struct is_sequence_impl;
-
+        
         template<>
         struct is_sequence_impl<deque_tag>
         {
             template<typename Sequence>
-            struct apply : mpl::true_ {};
+            struct apply
+              : mpl::true_
+            {};
         };
     }
 }}

include/boost/fusion/container/deque/detail/keyed_element.hpp

@@ -1,45 +1,47 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(BOOST_FUSION_DEQUE_DETAIL_KEYED_ELEMENT_26112006_1330)
 #define BOOST_FUSION_DEQUE_DETAIL_KEYED_ELEMENT_26112006_1330
 
-#include <boost/fusion/support/detail/access.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/add_const.hpp>
+
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/next.hpp>
 
-namespace boost { namespace fusion
-{
-    struct fusion_sequence_tag;
-}}
+namespace boost { namespace fusion {
+
+    struct fusion_sequence_tag;
+
+namespace detail {
 
-namespace boost { namespace fusion { namespace detail
-{
     struct nil_keyed_element
     {
         typedef fusion_sequence_tag tag;
         void get();
 
         template<typename It>
-        static nil_keyed_element
+        static nil_keyed_element 
         from_iterator(It const&)
         {
             return nil_keyed_element();
         }
     };
 
-    template <typename Key, typename Value, typename Rest>
-    struct keyed_element : Rest
+    template<typename Key, typename Value, typename Rest>
+    struct keyed_element
+        : Rest
     {
         typedef Rest base;
         typedef fusion_sequence_tag tag;
         using Rest::get;
 
-        template <typename It>
+        template<typename It>
         static keyed_element
         from_iterator(It const& it)
         {
@@ -47,65 +49,30 @@ namespace boost { namespace fusion { namespace detail
                 *it, base::from_iterator(fusion::next(it)));
         }
 
-        keyed_element(keyed_element const& rhs)
-          : Rest(rhs.get_base()), value_(rhs.value_)
-        {}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        keyed_element(keyed_element&& rhs)
-          : Rest(std::forward<Rest>(rhs.forward_base()))
-          , value_(std::forward<Value>(rhs.value_))
-        {}
-#endif
-
-        template <typename U, typename Rst>
+        template<typename U, typename Rst>
         keyed_element(keyed_element<Key, U, Rst> const& rhs)
-          : Rest(rhs.get_base()), value_(rhs.value_)
+            : Rest(rhs.get_base()), value_(rhs.value_)
         {}
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#endif
-
-        Rest& get_base()
+        Rest const get_base() const
         {
             return *this;
         }
 
-        Rest const& get_base() const
-        {
-            return *this;
-        }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        Rest&& forward_base()
-        {
-            return std::forward<Rest>(*static_cast<Rest*>(this));
-        }
-#endif
-
-        typename cref_result<Value>::type get(Key) const
+        typename add_reference<typename add_const<Value>::type>::type get(Key) const
         {
             return value_;
         }
 
-        typename ref_result<Value>::type get(Key)
+        typename add_reference<Value>::type get(Key)
         {
             return value_;
         }
 
-        keyed_element(
-            typename detail::call_param<Value>::type value
-          , Rest const& rest)
+        keyed_element(typename add_reference<typename add_const<Value>::type>::type value, Rest const& rest)
             : Rest(rest), value_(value)
         {}
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        keyed_element(Value&& value, Rest&& rest)
-            : Rest(std::forward<Rest>(rest))
-            , value_(std::forward<Value>(value))
-        {}
-#endif
-
         keyed_element()
             : Rest(), value_()
         {}
@@ -125,21 +92,12 @@ namespace boost { namespace fusion { namespace detail
             return *this;
         }
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        keyed_element& operator=(keyed_element&& rhs)
-        {
-            base::operator=(std::forward<keyed_element>(rhs));
-            value_ = std::forward<Value>(rhs.value_);
-            return *this;
-        }
-#endif
-
         Value value_;
     };
 
     template<typename Elem, typename Key>
     struct keyed_element_value_at
-      : keyed_element_value_at<typename Elem::base, Key>
+        : keyed_element_value_at<typename Elem::base, Key>
     {};
 
     template<typename Key, typename Value, typename Rest>
@@ -147,6 +105,7 @@ namespace boost { namespace fusion { namespace detail
     {
         typedef Value type;
     };
+
 }}}
 
 #endif

include/boost/fusion/container/deque/detail/preprocessed/as_deque.hpp

@@ -8,15 +8,15 @@
 ==============================================================================*/
 
 #if FUSION_MAX_DEQUE_SIZE <= 10
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque10.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/as_deque10.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 20
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque20.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/as_deque20.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 30
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque30.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/as_deque30.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 40
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque40.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/as_deque40.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 50
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/as_deque50.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/as_deque50.hpp>
 #else
 #error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
 #endif

include/boost/fusion/container/deque/detail/preprocessed/deque.hpp

@@ -8,15 +8,15 @@
 ==============================================================================*/
 
 #if FUSION_MAX_DEQUE_SIZE <= 10
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque10.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque10.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 20
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque20.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque20.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 30
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque30.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque30.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 40
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque40.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque40.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 50
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque50.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque50.hpp>
 #else
 #error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
 #endif

include/boost/fusion/container/deque/detail/preprocessed/deque_fwd.hpp

@@ -8,15 +8,15 @@
 ==============================================================================*/
 
 #if FUSION_MAX_DEQUE_SIZE <= 10
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque10_fwd.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque10_fwd.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 20
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque20_fwd.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque20_fwd.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 30
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque30_fwd.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque30_fwd.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 40
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque40_fwd.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque40_fwd.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 50
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque50_fwd.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque50_fwd.hpp>
 #else
 #error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
 #endif

include/boost/fusion/container/deque/detail/preprocessed/deque_initial_size.hpp

@@ -8,15 +8,15 @@
 ==============================================================================*/
 
 #if FUSION_MAX_DEQUE_SIZE <= 10
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size10.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size10.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 20
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size20.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size20.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 30
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size30.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size30.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 40
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size40.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size40.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 50
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_initial_size50.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size50.hpp>
 #else
 #error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
 #endif

include/boost/fusion/container/deque/detail/preprocessed/deque_keyed_values.hpp

@@ -8,15 +8,15 @@
 ==============================================================================*/
 
 #if FUSION_MAX_DEQUE_SIZE <= 10
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values10.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values10.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 20
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values20.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values20.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 30
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values30.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values30.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 40
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values40.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values40.hpp>
 #elif FUSION_MAX_DEQUE_SIZE <= 50
-#include <boost/fusion/container/deque/detail/cpp03/preprocessed/deque_keyed_values50.hpp>
+#include <boost/fusion/container/deque/detail/preprocessed/deque_keyed_values50.hpp>
 #else
 #error "FUSION_MAX_DEQUE_SIZE out of bounds for preprocessed headers"
 #endif

include/boost/fusion/container/deque/detail/value_at_impl.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 #if !defined(BOOST_FUSION_DEQUE_VALUE_AT_IMPL_08122006_0756)
@@ -13,15 +13,15 @@
 #include <boost/mpl/equal_to.hpp>
 #include <boost/mpl/assert.hpp>
 
-namespace boost { namespace fusion
-{
+namespace boost { namespace fusion { 
+
     struct deque_tag;
 
-    namespace extension
+    namespace extension 
     {
         template<typename T>
         struct value_at_impl;
-
+        
         template<>
         struct value_at_impl<deque_tag>
         {
@@ -31,12 +31,10 @@ namespace boost { namespace fusion
                 typedef typename Sequence::next_up next_up;
                 typedef typename Sequence::next_down next_down;
                 BOOST_MPL_ASSERT_RELATION(next_down::value, !=, next_up::value);
-
-                static int const offset = next_down::value + 1;
-                typedef mpl::int_<(N::value + offset)> adjusted_index;
-                typedef typename
-                    detail::keyed_element_value_at<Sequence, adjusted_index>::type
-                type;
+                
+                typedef mpl::plus<next_down, mpl::int_<1> > offset;
+                typedef mpl::int_<mpl::plus<N, offset>::value> adjusted_index;
+                typedef typename detail::keyed_element_value_at<Sequence, adjusted_index>::type type;
             };
         };
     }

include/boost/fusion/container/deque/front_extended_deque.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,39 +8,32 @@
 #if !defined(BOOST_FUSION_FRONT_EXTENDED_DEQUE_26112006_2209)
 #define BOOST_FUSION_FRONT_EXTENDED_DEQUE_26112006_2209
 
-#include <boost/mpl/int.hpp>
-#include <boost/fusion/support/sequence_base.hpp>
-#include <boost/fusion/sequence/intrinsic/size.hpp>
 #include <boost/fusion/container/deque/detail/keyed_element.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/minus.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#include <boost/fusion/support/sequence_base.hpp>
 
 namespace boost { namespace fusion
 {
-    template <typename Deque, typename T>
+    template<typename Deque, typename T>
     struct front_extended_deque
-      : detail::keyed_element<typename Deque::next_down, T, Deque>
-      , sequence_base<front_extended_deque<Deque, T> >
+        : detail::keyed_element<typename Deque::next_down, T, Deque>,
+          sequence_base<front_extended_deque<Deque, T> >
     {
         typedef detail::keyed_element<typename Deque::next_down, T, Deque> base;
-        typedef mpl::int_<(Deque::next_down::value - 1)> next_down;
+        typedef mpl::int_<mpl::minus<typename Deque::next_down, mpl::int_<1> >::value> next_down;
         typedef typename Deque::next_up next_up;
-        typedef mpl::int_<(result_of::size<Deque>::value + 1)> size;
+        typedef mpl::plus<typename result_of::size<Deque>::type, mpl::int_<1> > size;
 
-        template <typename Arg>
-        front_extended_deque(Deque const& deque, Arg const& val)
-          : base(val, deque)
+        front_extended_deque(Deque const& deque, typename add_reference<typename add_const<T>::type>::type t)
+            : base(t, deque)
         {}
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-        template <typename Arg>
-        front_extended_deque(Deque const& deque, Arg& val)
-          : base(val, deque)
-        {}
-#else
-        template <typename Arg>
-        front_extended_deque(Deque const& deque, Arg&& val)
-          : base(std::forward<Arg>(val), deque)
-        {}
-#endif
     };
 }}
 

include/boost/fusion/container/deque/limits.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2012 Joel de Guzman
+    Copyright (c) 2005-2011 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,10 +8,6 @@
 #if !defined(BOOST_FUSION_DEQUE_LIMITS_26112006_1737)
 #define BOOST_FUSION_DEQUE_LIMITS_26112006_1737
 
-#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-#error "C++03 only! This file should not have been included"
-#endif
-
 #include <boost/fusion/container/vector/limits.hpp>
 
 #if !defined(FUSION_MAX_DEQUE_SIZE)

include/boost/fusion/container/generation/cons_tie.hpp

@@ -11,11 +11,11 @@
 
 namespace boost { namespace fusion
 {
-    struct nil_;
+    struct nil;
 
     namespace result_of
     {
-        template <typename Car, typename Cdr = nil_>
+        template <typename Car, typename Cdr = nil>
         struct cons_tie
         {
             typedef cons<Car&, Cdr> type;

include/boost/fusion/container/generation/deque_tie.hpp

@@ -1,23 +1,41 @@
 /*=============================================================================
-    Copyright (c) 2001-2013 Joel de Guzman
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
-#if !defined(FUSION_DEQUE_TIE_01272013_1401)
-#define FUSION_DEQUE_TIE_01272013_1401
+#ifndef BOOST_PP_IS_ITERATING
+#if !defined(FUSION_DEQUE_TIE_07192005_1242)
+#define FUSION_DEQUE_TIE_07192005_1242
 
+#include <boost/preprocessor/iterate.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/fusion/container/deque/deque.hpp>
 
-#if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
-# include <boost/fusion/container/generation/detail/pp_deque_tie.hpp>
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/container/generation/detail/preprocessed/deque_tie.hpp>
 #else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque_tie" FUSION_MAX_DEQUE_SIZE_STR".hpp")
+#endif
 
-///////////////////////////////////////////////////////////////////////////////
-// C++11 variadic interface
-///////////////////////////////////////////////////////////////////////////////
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
 
-#include <boost/fusion/support/detail/as_fusion_element.hpp>
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    This is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
 
 namespace boost { namespace fusion
 {
@@ -25,21 +43,63 @@ namespace boost { namespace fusion
 
     namespace result_of
     {
-        template <typename ...T>
-        struct deque_tie
+        template <
+            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
+                FUSION_MAX_DEQUE_SIZE, typename T, void_)
+          , typename Extra = void_
+        >
+        struct deque_tie;
+    }
+
+#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
+
+#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/deque_tie.hpp>
+#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_FUSION_REF
+
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif
+#else // defined(BOOST_PP_IS_ITERATING)
+///////////////////////////////////////////////////////////////////////////////
+//
+//  Preprocessor vertical repetition code
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#define N BOOST_PP_ITERATION()
+
+    namespace result_of
     {
-            typedef deque<T&...> type;
+        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
+        #define TEXT(z, n, text) , text
+        struct deque_tie< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_DEQUE_SIZE, TEXT, void_) >
+        #undef TEXT
+#else
+        struct deque_tie<BOOST_PP_ENUM_PARAMS(N, T)>
+#endif
+        {
+            typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
         };
     }
 
-    template <typename ...T>
-    inline deque<T&...>
-    deque_tie(T&... arg)
+    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
+    inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
+    deque_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
     {
-        return deque<T&...>(arg...);
+        return deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
+            BOOST_PP_ENUM_PARAMS(N, _));
     }
- }}
 
-#endif
-#endif
+#undef N
+#endif // defined(BOOST_PP_IS_ITERATING)
 

include/boost/fusion/container/generation/detail/pp_deque_tie.hpp

@@ -1,105 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2006 Dan Marsden
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_PP_DEQUE_TIE_07192005_1242)
-#define FUSION_PP_DEQUE_TIE_07192005_1242
-
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/fusion/container/deque/deque.hpp>
-
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/generation/detail/preprocessed/deque_tie.hpp>
-#else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/deque_tie" FUSION_MAX_DEQUE_SIZE_STR".hpp")
-#endif
-
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
-
-namespace boost { namespace fusion
-{
-    struct void_;
-
-    namespace result_of
-    {
-        template <
-            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_DEQUE_SIZE, typename T, void_)
-          , typename Extra = void_
-        >
-        struct deque_tie;
-    }
-
-#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
-
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_deque_tie.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef BOOST_FUSION_REF
-
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#endif
-#else // defined(BOOST_PP_IS_ITERATING)
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Preprocessor vertical repetition code
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#define N BOOST_PP_ITERATION()
-
-    namespace result_of
-    {
-        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
-        #define TEXT(z, n, text) , text
-        struct deque_tie< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_DEQUE_SIZE, TEXT, void_) >
-        #undef TEXT
-#else
-        struct deque_tie<BOOST_PP_ENUM_PARAMS(N, T)>
-#endif
-        {
-            typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
-        };
-    }
-
-    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-    inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
-    deque_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
-    {
-        return deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
-            BOOST_PP_ENUM_PARAMS(N, _));
-    }
-
-#undef N
-#endif // defined(BOOST_PP_IS_ITERATING)
-

include/boost/fusion/container/generation/detail/pp_make_deque.hpp

@@ -1,121 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-    Copyright (c) 2006 Dan Marsden
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_PP_MAKE_DEQUE_07162005_0243)
-#define FUSION_MAKE_PP_DEQUE_07162005_0243
-
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/fusion/container/deque/deque.hpp>
-#include <boost/fusion/support/detail/as_fusion_element.hpp>
-
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/generation/detail/preprocessed/make_deque.hpp>
-#else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_deque" FUSION_MAX_DEQUE_SIZE_STR".hpp")
-#endif
-
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
-
-namespace boost { namespace fusion
-{
-    struct void_;
-
-    namespace result_of
-    {
-        template <
-            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_DEQUE_SIZE, typename T, void_)
-          , typename Extra = void_
-        >
-        struct make_deque;
-
-        template <>
-        struct make_deque<>
-        {
-            typedef deque<> type;
-        };
-    }
-
-    inline deque<>
-    make_deque()
-    {
-        return deque<>();
-    }
-
-#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
-    typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
-
-#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data)                               \
-    typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
-
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_deque.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef BOOST_FUSION_AS_FUSION_ELEMENT
-
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#endif
-#else // defined(BOOST_PP_IS_ITERATING)
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Preprocessor vertical repetition code
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#define N BOOST_PP_ITERATION()
-
-    namespace result_of
-    {
-        template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
-        #define TEXT(z, n, text) , text
-        struct make_deque< BOOST_PP_ENUM_PARAMS(N, T) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_DEQUE_SIZE, TEXT, void_) >
-        #undef TEXT
-#else
-        struct make_deque<BOOST_PP_ENUM_PARAMS(N, T)>
-#endif
-        {
-            typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
-        };
-    }
-
-    template <BOOST_PP_ENUM_PARAMS(N, typename T)>
-    inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
-    make_deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
-    {
-        return deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
-            BOOST_PP_ENUM_PARAMS(N, _));
-    }
-
-#undef N
-#endif // defined(BOOST_PP_IS_ITERATING)
-

include/boost/fusion/container/generation/detail/pp_make_map.hpp

@@ -1,132 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-==============================================================================*/
-#ifndef BOOST_PP_IS_ITERATING
-#if !defined(FUSION_PP_MAKE_MAP_07222005_1247)
-#define FUSION_PP_MAKE_MAP_07222005_1247
-
-#include <boost/preprocessor/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-#include <boost/fusion/container/map/map.hpp>
-#include <boost/fusion/support/detail/as_fusion_element.hpp>
-#include <boost/fusion/support/pair.hpp>
-
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/generation/detail/preprocessed/make_map.hpp>
-#else
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/make_map" FUSION_MAX_MAP_SIZE_STR".hpp")
-#endif
-
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-    This is an auto-generated file. Do not edit!
-==============================================================================*/
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(preserve: 1)
-#endif
-
-namespace boost { namespace fusion
-{
-    struct void_;
-
-    namespace result_of
-    {
-        template <
-            BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_VECTOR_SIZE, typename K, void_)
-          , BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-                FUSION_MAX_VECTOR_SIZE, typename D, void_)
-          , typename Extra = void_
-        >
-        struct make_map;
-
-        template <>
-        struct make_map<>
-        {
-            typedef map<> type;
-        };
-    }
-
-    inline map<>
-    make_map()
-    {
-        return map<>();
-    }
-
-#define BOOST_FUSION_PAIR(z, n, data)                                           \
-    fusion::pair<                                                               \
-        BOOST_PP_CAT(K, n)                                                      \
-      , typename detail::as_fusion_element<BOOST_PP_CAT(D, n)>::type>
-
-#define BOOST_FUSION_MAKE_PAIR(z, n, data)                                      \
-    fusion::make_pair<BOOST_PP_CAT(K, n)>(BOOST_PP_CAT(_, n))                   \
-
-#define BOOST_PP_FILENAME_1 <boost/fusion/container/generation/detail/pp_make_map.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
-#include BOOST_PP_ITERATE()
-
-#undef BOOST_FUSION_PAIR
-#undef BOOST_FUSION_MAKE_PAIR
-
-}}
-
-#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
-#pragma wave option(output: null)
-#endif
-
-#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
-
-#endif
-#else // defined(BOOST_PP_IS_ITERATING)
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Preprocessor vertical repetition code
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#define N BOOST_PP_ITERATION()
-
-    namespace result_of
-    {
-        template <
-            BOOST_PP_ENUM_PARAMS(N, typename K)
-          , BOOST_PP_ENUM_PARAMS(N, typename D)
-        >
-#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
-         #define TEXT(z, n, text) , text
-         struct make_map<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D) BOOST_PP_REPEAT_FROM_TO(N, FUSION_MAX_VECTOR_SIZE, TEXT, void_) BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(N), FUSION_MAX_VECTOR_SIZE, TEXT, void_)>
-         #undef TEXT
-#else
-        struct make_map<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D)>
-#endif
-        {
-            typedef map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)> type;
-        };
-    }
-
-    template <
-        BOOST_PP_ENUM_PARAMS(N, typename K)
-      , BOOST_PP_ENUM_PARAMS(N, typename D)
-    >
-    inline map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)>
-    make_map(BOOST_PP_ENUM_BINARY_PARAMS(N, D, const& _))
-    {
-        return map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)>(
-            BOOST_PP_ENUM(N, BOOST_FUSION_MAKE_PAIR, _));
-    }
-
-#undef N
-#endif // defined(BOOST_PP_IS_ITERATING)
-