Release 1.55.0

[SVN r86621]

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_ADT(
+    BOOST_FUSION_ADAPT_TPL_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,6 +1115,100 @@ 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]
@@ -1162,14 +1256,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
@@ -1177,7 +1271,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,
@@ -1238,14 +1332,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
@@ -1253,7 +1347,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,6 +44,5 @@ 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,10 +21,11 @@ __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, 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 (a
+vector with N elements is just a struct with N members), and in many
+cases the most efficient.
 
 [heading Header]
 
@@ -95,7 +96,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]
@@ -156,7 +157,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`]]
 ]
 
@@ -246,7 +247,7 @@ including any Fusion header to change the default. Example:
 
 [table
     [[Parameter]            [Description]               [Default]]
-    [[`T0`...`TN`]          [Element types]             [['unspecified-type]]]
+    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
 ]
 
 [heading Model of]
@@ -289,6 +290,220 @@ 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]
@@ -332,7 +547,7 @@ including any Fusion header to change the default. Example:
 
 [table
     [[Parameter]            [Description]               [Default]]
-    [[`T0`...`TN`]          [Element types]             [['unspecified-type]]]
+    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
 ]
 
 [heading Model of]
@@ -414,13 +629,13 @@ including any Fusion header to change the default. Example:
 
 [table
     [[Parameter]            [Description]               [Default]]
-    [[`T0`...`TN`]          [Element types]             [['unspecified-type]]]
+    [[`T0`...`TN`]          [Element types]             [__unspecified__]]
 ]
 
 [heading Model of]
 
 * __associative_sequence__
-* __random_access_sequence__
+* __forward_sequence__
 
 [variablelist Notation
     [[`M`]              [A `map` type]]
@@ -432,7 +647,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 __forward_sequence__ and __associative_sequence__.
+defined in __random_access_sequence__ and __associative_sequence__.
 
 [table
     [[Expression]           [Semantics]]
@@ -617,6 +832,58 @@ __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]
@@ -682,7 +949,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
@@ -734,6 +1001,7 @@ succeeding sections document the various /tier/ flavors.
 * __list_tie__
 * __vector_tie__
 * __map_tie__
+* __deque_tie__
 
 Example:
 
@@ -914,6 +1182,56 @@ 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]
@@ -1039,8 +1357,8 @@ rules for __element_conversion__.
 
 [heading Header]
 
-    #include <boost/fusion/container/generation/make_vector.hpp>
-    #include <boost/fusion/include/make_vector.hpp>
+    #include <boost/fusion/container/generation/make_list.hpp>
+    #include <boost/fusion/include/make_list.hpp>
 
 [heading Example]
 
@@ -1048,6 +1366,54 @@ 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]
@@ -1240,6 +1606,53 @@ 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]
@@ -1388,6 +1801,48 @@ 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]
@@ -1559,6 +2014,44 @@ 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.2]
+    [version 2.1]
     [authors [de Guzman, Joel], [Marsden, Dan], [Schwinger, Tobias]]
-    [copyright 2001 2002 2003 2004 2005 2006 2011 Joel de Guzman, Dan Marsden, Tobias Schwinger]
+    [copyright 2001 2002 2003 2004 2005 2006 2011 2012 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,6 +116,9 @@
 [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`]]
 
@@ -198,12 +201,16 @@
 [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,7 +161,6 @@ 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__)
@@ -207,7 +206,6 @@ the following expressions must be valid:
 
 [heading Models]
 * __vector__ iterator
-* __map__ iterator
 * __std_pair__ iterator
 * __boost_array__ iterator
 * __single_view__ iterator
@@ -494,7 +492,7 @@ Deferences the data property associated with the element referenced by an associ
     template<
         typename I
         >
-    typename __result_of_deref_data__<I>::type deref(I const& i);
+    typename __result_of_deref_data__<I>::type deref_data(I const& i);
 
 [table Parameters
     [[Parameter]      [Requirement]    [Description]]
@@ -995,9 +993,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]
@@ -1034,9 +1032,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,7 +189,6 @@ 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)
@@ -266,7 +265,6 @@ 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)
@@ -850,7 +848,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]
@@ -1378,7 +1376,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 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 no effect.
 
 [endsect]
 
@@ -254,7 +254,7 @@ The __tr1__tuple__ interface is specified to provide uniform access to `std::pai
 
 [*Type]: `T2`
 
-[*Value]: Returns thetype of the second element of the pair
+[*Value]: Returns the type 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_VARIADIC_TEMPLATES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/fusion/adapted/std_tuple.hpp>
 #endif
 

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

@@ -12,13 +12,28 @@
 
 #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/eval_if.hpp>
+#include <boost/mpl/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 std::tuple_element<N::value, seq_type> element;
+                typedef typename std::tuple_element<N::value, seq_type>::type element;
 
                 typedef typename
-                    mpl::eval_if<
+                    mpl::if_<
                         is_const<Sequence>
-                      , fusion::detail::cref_result<element>
-                      , fusion::detail::ref_result<element>
+                      , typename fusion::detail::cref_result<element>::type
+                      , typename fusion::detail::ref_result<element>::type
                     >::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/eval_if.hpp>
+#include <boost/mpl/if.hpp>
 #include <tuple>
 #include <utility>
 
@@ -48,12 +48,12 @@ namespace boost { namespace fusion
         template <typename Iterator>
         struct deref
         {
-            typedef value_of<Iterator> element;
+            typedef typename value_of<Iterator>::type element;
             typedef typename
-                mpl::eval_if<
+                mpl::if_<
                     is_const<typename Iterator::tuple_type>
-                  , fusion::detail::cref_result<element>
-                  , fusion::detail::ref_result<element>
+                  , typename fusion::detail::cref_result<element>::type
+                  , typename fusion::detail::ref_result<element>::type
                 >::type
             type;
 

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

@@ -10,12 +10,6 @@
 #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,5 +16,6 @@
 #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

@@ -0,0 +1,25 @@
+/*=============================================================================
+    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

@@ -0,0 +1,523 @@
+/*=============================================================================
+    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,8 +11,11 @@
 #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)
@@ -54,11 +57,19 @@ namespace boost { namespace fusion
     }
 
     template <typename Seq1, typename Seq2>
-    inline void
+    inline
+    typename
+        enable_if_c<
+            type_traits::ice_and<
+                traits::is_sequence<Seq1>::value
+              , traits::is_sequence<Seq2>::value
+            >::value,
+            void
+        >::type
     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

@@ -0,0 +1,84 @@
+/*=============================================================================
+    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,6 +9,8 @@
 
 #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
 {
@@ -23,14 +25,24 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename State, typename F>
-    inline typename result_of::accumulate<Sequence, State const, F>::type
+    inline 
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , 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 result_of::accumulate<Sequence const, State const, F>::type
+    inline 
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , 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,6 +7,9 @@
 #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
@@ -16,11 +19,19 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename State, typename F>
-    typename result_of::accumulate<Sequence, State const, F>::type
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::accumulate<Sequence, State const, F>
+        >::type
     accumulate(Sequence& seq, State const& state, F f);
 
     template <typename Sequence, typename State, typename F>
-    typename result_of::accumulate<Sequence const, State const, F>::type
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , 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& it0, F)
+            call(State const& state,It0 const&, 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& it0, F)
+            call(State const& state,It0 const&, F)
             {
                 return static_cast<Result>(state);
             }

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

@@ -11,6 +11,8 @@
 #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
 {
@@ -24,14 +26,24 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F>
-    inline void
+    inline
+    typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
     for_each(Sequence& seq, F const& f)
     {
         detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
     }
 
     template <typename Sequence, typename F>
-    inline void
+    inline
+    typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
     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,6 +7,9 @@
 #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
@@ -16,11 +19,21 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F>
-    void
+    inline
+    typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
     for_each(Sequence& seq, F const& f);
 
     template <typename Sequence, typename F>
-    void
+    inline
+    typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
     for_each(Sequence const& seq, F const& f);
 }}
 

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

@@ -10,6 +10,8 @@
 
 #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
 {
@@ -23,7 +25,12 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename T>
-    inline int
+    inline
+    typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , int
+        >::type
     count(Sequence const& seq, T const& x)
     {
         detail::count_compare<T> f(x);

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

@@ -10,6 +10,8 @@
 
 #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
 {
@@ -23,7 +25,12 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F>
-    inline int
+    inline 
+    typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , int
+        >::type
     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& it, F f)
+        static bool call(It const&, F)
         {
             return false;
         }

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

@@ -16,6 +16,9 @@
 #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
 {
@@ -53,18 +56,38 @@ 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 = typename compute_erase_last<Sequence, First>::type>
+          , typename Last = use_default>
         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 typename convert_iterator<First>::type first_type;
-            typedef typename convert_iterator<Last>::type last_type;
+            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 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;
@@ -72,7 +95,11 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename First>
-    typename result_of::erase<Sequence const, First>::type
+    typename 
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , 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,6 +16,8 @@
 #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
 {
@@ -38,8 +40,12 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename Position, typename T>
-    inline typename result_of::insert<
-        Sequence const, Position, T>::type
+    inline 
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , 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,6 +10,8 @@
 #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
 {
@@ -24,7 +26,12 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename T>
-    inline typename result_of::push_back<Sequence const, T>::type
+    inline 
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , 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,6 +10,8 @@
 #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
 {
@@ -24,7 +26,12 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename T>
-    inline typename result_of::push_front<Sequence const, T>::type
+    inline 
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , 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,6 +9,8 @@
 
 #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
 {
@@ -22,7 +24,12 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename T>
-    inline typename result_of::replace<Sequence const, T>::type
+    inline 
+    typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , typename result_of::replace<Sequence const, T>::type
+        >::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,6 +9,7 @@
 
 #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>
 
@@ -24,7 +25,12 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence, typename F, typename T>
-    inline typename result_of::replace_if<Sequence const, F, T>::type
+    inline 
+    typename 
+        enable_if<
+            traits::is_sequence<Sequence>
+          , typename result_of::replace_if<Sequence const, F, T>::type
+        >::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,6 +8,8 @@
 #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
 {
@@ -21,7 +23,12 @@ namespace boost { namespace fusion
     }
 
     template <typename Sequence>
-    inline reverse_view<Sequence const>
+    inline 
+    typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , reverse_view<Sequence const>
+        >::type
     reverse(Sequence const& view)
     {
         return reverse_view<Sequence const>(view);

include/boost/fusion/container/deque.hpp

@@ -8,6 +8,7 @@
 #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,36 +1,47 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2012 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>
 
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/add_reference.hpp>
-
-namespace boost { namespace fusion {
-    template<typename Deque, typename T>
+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_<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;
+        typedef mpl::int_<(Deque::next_up::value + 1)> next_up;
+        typedef mpl::int_<(result_of::size<Deque>::value + 1)> size;
 
-        back_extended_deque(Deque const& deque, typename add_reference<typename add_const<T>::type>::type t)
-            : base(t, deque)
+        template <typename Arg>
+        back_extended_deque(Deque const& deque, Arg const& val)
+          : base(val, 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-2011 Joel de Guzman
+    Copyright (c) 2005-2013 Joel de Guzman
     Copyright (c) 2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,23 +8,32 @@
 #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>
-#include <boost/fusion/sequence/intrinsic/begin.hpp>
-#include <boost/fusion/sequence/intrinsic/size.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>
 
 namespace boost { namespace fusion
 {
     namespace result_of
     {
         template <typename Sequence>
-        struct as_deque
+        struct as_deque :
+            detail::build_deque<
+                typename result_of::begin<Sequence>::type
+              , typename result_of::end<Sequence>::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;
         };
     }
 
@@ -32,17 +41,18 @@ namespace boost { namespace fusion
     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));
+        typedef result_of::as_deque<Sequence> gen;
+        return gen::call(fusion::begin(seq), fusion::end(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));
+        typedef result_of::as_deque<Sequence const> gen;
+        return gen::call(fusion::begin(seq), fusion::end(seq));
     }
 }}
 
 #endif
+#endif

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

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2012 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,20 +8,23 @@
 #if !defined(BOOST_FUSION_DEQUE_26112006_1649)
 #define BOOST_FUSION_DEQUE_26112006_1649
 
-#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>
 
+///////////////////////////////////////////////////////////////////////////////
+// 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/detail/deque_keyed_values.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>
@@ -29,93 +32,129 @@
 #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/sequence/intrinsic/empty.hpp>
 
-#include <boost/fusion/support/sequence_base.hpp>
-#include <boost/fusion/support/void.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/and.hpp>
 #include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_convertible.hpp>
 
-#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 {
-
+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)> >
+    template <typename ...Elements>
+    struct deque : detail::nil_keyed_element
     {
         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::int_<0> size;
+        typedef mpl::int_<0> next_up;
+        typedef mpl::int_<0> next_down;
         typedef mpl::false_ is_view;
 
-#include <boost/fusion/container/deque/detail/deque_forward_ctor.hpp>
+        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 mpl::int_<size::value> next_up;
+        typedef mpl::int_<((size::value == 0) ? 0 : -1)> next_down;
+        typedef mpl::false_ is_view;
 
         deque()
-            {}
+        {}
 
-        explicit deque(typename add_reference<typename add_const<T0>::type>::type t0)
-            : base(t0, detail::nil_keyed_element())
-            {}
+        template <typename ...Elements>
+        deque(deque<Elements...> const& 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)
-            {}
+        template <typename ...Elements>
+        deque(deque<Elements...>& seq)
+          : base(seq)
+        {}
 
-        template<typename Sequence>
-            deque(Sequence const& seq, typename disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0)
-            : base(base::from_iterator(fusion::begin(seq)))
-            {}
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+        template <typename ...Elements>
+        deque(deque<Elements...>&& seq)
+          : base(std::forward<deque<Elements...>>(seq))
+        {}
+#endif
 
-        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)
+        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)
         {
             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-2011 Joel de Guzman
+    Copyright (c) 2005-2012 Joel de Guzman
     Copyright (c) 2005-2007 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,43 +8,28 @@
 #if !defined(FUSION_DEQUE_FORWARD_02092007_0749)
 #define FUSION_DEQUE_FORWARD_02092007_0749
 
-#include <boost/fusion/container/deque/limits.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/config.hpp>
 
-#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/deque/detail/preprocessed/deque_fwd.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>
 #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 "_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
+# if !defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
+#   define BOOST_FUSION_HAS_VARIADIC_DEQUE
+# endif
 
+///////////////////////////////////////////////////////////////////////////////
+// C++11 interface
+///////////////////////////////////////////////////////////////////////////////
 namespace boost { namespace fusion
 {
-    struct void_;
-
-    template<
-        BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-            FUSION_MAX_DEQUE_SIZE, typename T, void_)>
+    template <typename ...T>
     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-2011 Joel de Guzman
+    Copyright (c) 2005-2012 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/at_impl.hpp

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2012 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,15 +37,21 @@ 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);
-                
-                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 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;
 
                 static type call(Sequence& seq)
                 {

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

@@ -1,8 +1,8 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2012 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,27 +13,29 @@
 #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_<
-                    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;
-                
+                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;
+
                 static type call(Sequence& seq)
                 {
                     return type(seq);

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

@@ -0,0 +1,74 @@
+/*=============================================================================
+    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-2011 Joel de Guzman
+    Copyright (c) 2005-2012 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/detail/as_deque.hpp>
+#include <boost/fusion/container/deque/convert.hpp>
 #include <boost/fusion/container/deque/deque.hpp>
 #include <boost/fusion/sequence/intrinsic/begin.hpp>
 #include <boost/fusion/sequence/intrinsic/size.hpp>
@@ -17,6 +17,12 @@ namespace boost { namespace fusion
 {
     struct deque_tag;
 
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct as_deque;
+    }
+
     namespace extension
     {
         template <typename T>
@@ -28,14 +34,11 @@ namespace boost { namespace fusion
             template <typename Sequence>
             struct apply
             {
-                typedef typename detail::as_deque<result_of::size<Sequence>::value> gen;
-                typedef typename gen::
-                    template apply<typename result_of::begin<Sequence>::type>::type
-                type;
-
+                typedef result_of::as_deque<Sequence> gen;
+                typedef typename gen::type type;
                 static type call(Sequence& seq)
                 {
-                    return gen::call(fusion::begin(seq));
+                    return gen::call(seq);
                 }
             };
         };

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

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2012 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/preprocessed/as_deque.hpp>
+#include <boost/fusion/container/deque/detail/cpp03/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/as_deque.hpp>
+#define BOOST_PP_FILENAME_1 <boost/fusion/container/deque/detail/cpp03/as_deque.hpp>
 #define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
 #include BOOST_PP_ITERATE()
 

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

@@ -0,0 +1,52 @@
+/*=============================================================================
+    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

@@ -0,0 +1,181 @@
+/*=============================================================================
+    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_forward_ctor.hpp

@@ -1,31 +1,52 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2012 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/deque_forward_ctor.hpp>
+    <boost/fusion/container/deque/detail/cpp03/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)>::call(BOOST_PP_ENUM_PARAMS(N, t)))
+    : base(detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(N, T)>::construct(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/cpp03/deque_fwd.hpp

@@ -0,0 +1,54 @@
+/*=============================================================================
+    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_initial_size.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2012 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,6 +8,10 @@
 #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>
@@ -21,7 +25,7 @@ namespace boost { namespace fusion
 }}
 
 #if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
-#include <boost/fusion/container/deque/detail/preprocessed/deque_initial_size.hpp>
+#include <boost/fusion/container/deque/detail/cpp03/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/cpp03/deque_keyed_values.hpp

@@ -0,0 +1,111 @@
+/*=============================================================================
+    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

@@ -0,0 +1,61 @@
+/*=============================================================================
+    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/cpp03/limits.hpp

@@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    Copyright (c) 2005-2012 Joel de Guzman
     Copyright (c) 2005-2006 Dan Marsden
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -8,6 +8,10 @@
 #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/deque/detail/cpp03/preprocessed/as_deque.hpp

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

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

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

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

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

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

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

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

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

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

@@ -1,102 +1,67 @@
 /*=============================================================================
-    Copyright (c) 2005-2011 Joel de Guzman
+    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_DEQUE_DETAIL_CPP11_DEQUE_KEYED_VALUES_07042012_1901)
+#define BOOST_FUSION_DEQUE_DETAIL_CPP11_DEQUE_KEYED_VALUES_07042012_1901
 
-#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/mpl/plus.hpp>
+#include <boost/type_traits/add_const.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;
 
-    struct nil_keyed_element;
-
-    template<typename N, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
+    template <typename N, typename ...Elements>
     struct deque_keyed_values_impl;
 
-    template<typename N>
-    struct deque_keyed_values_impl<N, BOOST_PP_ENUM(FUSION_MAX_DEQUE_SIZE, FUSION_VOID, _)>
+    template <typename N, typename Head, typename ...Tail>
+    struct deque_keyed_values_impl<N, Head, Tail...>
     {
-        typedef nil_keyed_element type;
+        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 call()
+        static type construct(
+          typename detail::call_param<Head>::type head
+        , typename detail::call_param<Tail>::type... tail)
         {
-            return type();
+            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)...)
+            );
         }
     };
 
-    template<typename N, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>
-    struct deque_keyed_values_impl
+    struct nil_keyed_element;
+
+    template <typename N>
+    struct deque_keyed_values_impl<N>
     {
-        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>
-
+        typedef nil_keyed_element type;
+        static type construct() { return type(); }
+        static type forward_() { return type(); }
     };
 
-    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
+    template <typename ...Elements>
     struct deque_keyed_values
-        : deque_keyed_values_impl<mpl::int_<0>, BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>
-    {};
-
+      : deque_keyed_values_impl<mpl::int_<0>, Elements...> {};
 }}}
 
-#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

@@ -1,38 +0,0 @@
-/*=============================================================================
-    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-2011 Joel de Guzman
+    Copyright (c) 2005-2012 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,27 +13,29 @@
 #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_<
-                    mpl::equal_to<typename Sequence::next_down, typename Sequence::next_up>,
-                    deque_iterator<Sequence, 0>,
-                    deque_iterator<
-                    Sequence, Sequence::next_up::value> >::type type;
-                
+                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;
+
                 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,18 +14,16 @@ 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_ {};
         };
     }
 }}