diff --git a/doc/data.html b/doc/data.html index f1dc401..c3e45ea 100644 --- a/doc/data.html +++ b/doc/data.html @@ -9,6 +9,7 @@ diff --git a/doc/data/arrays.html b/doc/data/arrays.html index 6274eb2..393d5c8 100644 --- a/doc/data/arrays.html +++ b/doc/data/arrays.html @@ -2,7 +2,6 @@ arrays.html -

Arrays

diff --git a/doc/data/lists.html b/doc/data/lists.html index 3f0fabb..98a32c9 100644 --- a/doc/data/lists.html +++ b/doc/data/lists.html @@ -2,7 +2,6 @@ lists.html -

Lists

diff --git a/doc/data/sets.html b/doc/data/sets.html new file mode 100644 index 0000000..7747d43 --- /dev/null +++ b/doc/data/sets.html @@ -0,0 +1,57 @@ + + + sets.html + + + +

Sets

+
+ A set is a group of adjacent parenthesized elements. + For example, +
+
+ (a)(b)(c) +
+
+ ...is a set of 3 elements--a, b, and c. +
+
+ Sets are data structures that merge the properties of both lists and tuples + with the exception that sets cannot be empty.  + Therefore, an "empty" set is considered a special case scenario that must be handled separately in C++. +
+
+#define SET (x)(y)(z)
+#define REVERSE(s, state, elem) (elem) state
+   // append to head                  ^
+
+BOOST_PP_SET_FOLD_LEFT(REVERSE, BOOST_PP_EMPTY, SET)()
+   //                           #1                  #2
+   // 1) placeholder for "empty" set
+   // 2) remove placeholder
+
+#define SET_B (1)(2)(3)
+#define INC(s, state, elem) state (BOOST_PP_INC(elem))
+   // append to tail             ^
+
+BOOST_PP_SET_FOLD_RIGHT(INC, BOOST_PP_SET_NIL, SET)
+   //                        ^
+   // special placeholder that will be "eaten"
+   // by appending to the tail
+
+
+ Sets are extremely efficient.  + Element access speed approaches random access--even with sets of up to 256 elements.  + This is because element access (among other things) is implemented iteratively rather than recursively.  + Therefore, elements can be accessed at extremely high indices even on preprocessors with low maximum expansion depths. +
+
+ Elements of a set can be extracted with + BOOST_PP_SET_ELEM. +
+

Primitives

+ + + diff --git a/doc/data/tuples.html b/doc/data/tuples.html index ca01b2e..ee1db6c 100644 --- a/doc/data/tuples.html +++ b/doc/data/tuples.html @@ -2,7 +2,6 @@ tuples.html -

Tuples

diff --git a/doc/headers.html b/doc/headers.html index 5ab7183..70716c6 100644 --- a/doc/headers.html +++ b/doc/headers.html @@ -156,6 +156,33 @@
  • selection/
  • max.hpp
  • min.hpp
    • +
  • set.hpp
    • +
  • set/
    • +
  • cat.hpp
    • +
  • elem.hpp
    • +
  • enum.hpp
    • +
  • filter.hpp
    • +
  • first_n.hpp
    • +
  • fold_left.hpp
    • +
  • fold_right.hpp
    • +
  • for_each.hpp
    • +
  • for_each_i.hpp
    • +
  • for_each_product.hpp
    • +
  • insert.hpp
    • +
  • pop_back.hpp
    • +
  • pop_front.hpp
    • +
  • push_back.hpp
    • +
  • push_front.hpp
    • +
  • remove.hpp
    • +
  • replace.hpp
    • +
  • rest_n.hpp
    • +
  • reverse.hpp
    • +
  • set.hpp
    • +
  • size.hpp
    • +
  • subset.hpp
    • +
  • to_array.hpp
    • +
  • to_tuple.hpp
    • +
  • transform.hpp
  • slot.hpp
  • slot/
  • slot.hpp
    • @@ -166,6 +193,7 @@
  • rem.hpp
  • reverse.hpp
  • to_list.hpp
    • +
  • to_set.hpp
  • stringize.hpp
  • while.hpp*
    • diff --git a/doc/headers/config/limits.hpp.html b/doc/headers/config/limits.hpp.html index 794eae8..b728d13 100644 --- a/doc/headers/config/limits.hpp.html +++ b/doc/headers/config/limits.hpp.html @@ -19,6 +19,7 @@
  • BOOST_PP_LIMIT_ITERATION_DIM
  • BOOST_PP_LIMIT_MAG
  • BOOST_PP_LIMIT_REPEAT
    • +
  • BOOST_PP_LIMIT_SET
  • BOOST_PP_LIMIT_SLOT_COUNT
  • BOOST_PP_LIMIT_SLOT_SIG
  • BOOST_PP_LIMIT_TUPLE
    • diff --git a/doc/headers/set.hpp.html b/doc/headers/set.hpp.html new file mode 100644 index 0000000..9fed5cb --- /dev/null +++ b/doc/headers/set.hpp.html @@ -0,0 +1,43 @@ + + + set.hpp + + + +
    + The set.hpp includes the headers in the set folder. +
    +

    Usage

    +
    + #include <boost/preprocessor/set.hpp> +
    +

    Includes

    + + + diff --git a/doc/headers/set/cat.hpp.html b/doc/headers/set/cat.hpp.html new file mode 100644 index 0000000..eb2f4bf --- /dev/null +++ b/doc/headers/set/cat.hpp.html @@ -0,0 +1,20 @@ + + + set/cat.hpp + + + +
    + The set/cat.hpp header defines macros for concatenating all elements in a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/cat.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/elem.hpp.html b/doc/headers/set/elem.hpp.html new file mode 100644 index 0000000..b16aa19 --- /dev/null +++ b/doc/headers/set/elem.hpp.html @@ -0,0 +1,19 @@ + + + set/elem.hpp + + + +
    + The set/elem.hpp header defines a macro to extract an element from a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/elem.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/enum.hpp.html b/doc/headers/set/enum.hpp.html new file mode 100644 index 0000000..ccb5432 --- /dev/null +++ b/doc/headers/set/enum.hpp.html @@ -0,0 +1,19 @@ + + + set/enum.hpp + + + +
    + The set/enum.hpp header defines a macro to enumerate the elements in a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/enum.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/filter.hpp.html b/doc/headers/set/filter.hpp.html new file mode 100644 index 0000000..be89274 --- /dev/null +++ b/doc/headers/set/filter.hpp.html @@ -0,0 +1,20 @@ + + + set/filter.hpp + + + +
    + The set/filter.hpp header defines macros to filter a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/filter.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/first_n.hpp.html b/doc/headers/set/first_n.hpp.html new file mode 100644 index 0000000..280fe5d --- /dev/null +++ b/doc/headers/set/first_n.hpp.html @@ -0,0 +1,19 @@ + + + set/first_n.hpp + + + +
    + The set/first_n.hpp header defines a macro that returns the first N elements of a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/first_n.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/fold_left.hpp.html b/doc/headers/set/fold_left.hpp.html new file mode 100644 index 0000000..6b483a5 --- /dev/null +++ b/doc/headers/set/fold_left.hpp.html @@ -0,0 +1,20 @@ + + + set/fold_left.hpp + + + +
    + The set/fold_left.hpp header defines macros for folding (or accumulating) a set left-to-right. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/fold_left.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/fold_right.hpp.html b/doc/headers/set/fold_right.hpp.html new file mode 100644 index 0000000..f62cea3 --- /dev/null +++ b/doc/headers/set/fold_right.hpp.html @@ -0,0 +1,20 @@ + + + set/fold_right.hpp + + + +
    + The set/fold_right.hpp header defines macros for folding (or accumulating) a set right-to-left. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/fold_right.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/for_each.hpp.html b/doc/headers/set/for_each.hpp.html new file mode 100644 index 0000000..3433bd2 --- /dev/null +++ b/doc/headers/set/for_each.hpp.html @@ -0,0 +1,20 @@ + + + set/for_each.hpp + + + +
    + The set/for_each.hpp header defines macros to repeat a macro for each element in a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/for_each.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/for_each_i.hpp.html b/doc/headers/set/for_each_i.hpp.html new file mode 100644 index 0000000..0ff50e2 --- /dev/null +++ b/doc/headers/set/for_each_i.hpp.html @@ -0,0 +1,20 @@ + + + set/for_each_i.hpp + + + +
    + The set/for_each_i.hpp header defines macros to repeat a macro for each element in a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/for_each_i.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/for_each_product.hpp.html b/doc/headers/set/for_each_product.hpp.html new file mode 100644 index 0000000..62e33a2 --- /dev/null +++ b/doc/headers/set/for_each_product.hpp.html @@ -0,0 +1,20 @@ + + + set/for_each_product.hpp + + + +
    + The set/for_each_product.hpp header defines macros to repeat a macro for each cartesian product of several sets. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/for_each_product.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/insert.hpp.html b/doc/headers/set/insert.hpp.html new file mode 100644 index 0000000..afc7d47 --- /dev/null +++ b/doc/headers/set/insert.hpp.html @@ -0,0 +1,19 @@ + + + set/insert.hpp + + + +
    + The set/insert.hpp header defines a macro to insert an element into a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/insert.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/pop_back.hpp.html b/doc/headers/set/pop_back.hpp.html new file mode 100644 index 0000000..5c0c747 --- /dev/null +++ b/doc/headers/set/pop_back.hpp.html @@ -0,0 +1,19 @@ + + + set/pop_back.hpp + + + +
    + The set/pop_back.hpp header defines a macro to pop the last element off a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/pop_back.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/pop_front.hpp.html b/doc/headers/set/pop_front.hpp.html new file mode 100644 index 0000000..438d623 --- /dev/null +++ b/doc/headers/set/pop_front.hpp.html @@ -0,0 +1,19 @@ + + + set/pop_front.hpp + + + +
    + The set/pop_front.hpp header defines a macro to pop the first element off a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/pop_front.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/push_back.hpp.html b/doc/headers/set/push_back.hpp.html new file mode 100644 index 0000000..9491f1a --- /dev/null +++ b/doc/headers/set/push_back.hpp.html @@ -0,0 +1,19 @@ + + + set/push_back.hpp + + + +
    + The set/push_back.hpp header defines a macro to append an element to a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/push_back.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/push_front.hpp.html b/doc/headers/set/push_front.hpp.html new file mode 100644 index 0000000..cccbc18 --- /dev/null +++ b/doc/headers/set/push_front.hpp.html @@ -0,0 +1,19 @@ + + + set/push_front.hpp + + + +
    + The set/push_front.hpp header defines a macro to prepend an element to a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/push_front.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/remove.hpp.html b/doc/headers/set/remove.hpp.html new file mode 100644 index 0000000..61a3580 --- /dev/null +++ b/doc/headers/set/remove.hpp.html @@ -0,0 +1,19 @@ + + + set/remove.hpp + + + +
    + The set/remove.hpp header defines a macro to remove an element from a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/remove.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/replace.hpp.html b/doc/headers/set/replace.hpp.html new file mode 100644 index 0000000..453e45d --- /dev/null +++ b/doc/headers/set/replace.hpp.html @@ -0,0 +1,19 @@ + + + set/replace.hpp + + + +
    + The set/replace.hpp header defines a macro to replace an element in a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/replace.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/rest_n.hpp.html b/doc/headers/set/rest_n.hpp.html new file mode 100644 index 0000000..9cb2063 --- /dev/null +++ b/doc/headers/set/rest_n.hpp.html @@ -0,0 +1,19 @@ + + + set/rest_n.hpp + + + +
    + The set/rest_n.hpp header defines a macro for extracting a group of elements from the end of a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/rest_n.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/reverse.hpp.html b/doc/headers/set/reverse.hpp.html new file mode 100644 index 0000000..94e9817 --- /dev/null +++ b/doc/headers/set/reverse.hpp.html @@ -0,0 +1,20 @@ + + + set/reverse.hpp + + + +
    + The set/reverse.hpp header defines macros to reverse a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/reverse.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/set.hpp.html b/doc/headers/set/set.hpp.html new file mode 100644 index 0000000..6920a65 --- /dev/null +++ b/doc/headers/set/set.hpp.html @@ -0,0 +1,21 @@ + + + set/set.hpp + + + +
    + The set/set.hpp header defines basic primitives for manipulating sets. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/set.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/size.hpp.html b/doc/headers/set/size.hpp.html new file mode 100644 index 0000000..2231438 --- /dev/null +++ b/doc/headers/set/size.hpp.html @@ -0,0 +1,19 @@ + + + set/size.hpp + + + +
    + The set/size.hpp header defines a macro to calculate the size of a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/size.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/subset.hpp.html b/doc/headers/set/subset.hpp.html new file mode 100644 index 0000000..6224951 --- /dev/null +++ b/doc/headers/set/subset.hpp.html @@ -0,0 +1,19 @@ + + + set/subset.hpp + + + +
    + The set/subset.hpp header defines a macro that extracts a subset from a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/subset.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/to_array.hpp.html b/doc/headers/set/to_array.hpp.html new file mode 100644 index 0000000..309ab11 --- /dev/null +++ b/doc/headers/set/to_array.hpp.html @@ -0,0 +1,19 @@ + + + set/to_array.hpp + + + +
    + The set/to_array.hpp header defines a macro that converts a set to an array. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/to_array.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/to_tuple.hpp.html b/doc/headers/set/to_tuple.hpp.html new file mode 100644 index 0000000..71b26df --- /dev/null +++ b/doc/headers/set/to_tuple.hpp.html @@ -0,0 +1,19 @@ + + + set/to_tuple.hpp + + + +
    + The set/to_tuple.hpp header defines a macro that converts a set to an tuple. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/to_tuple.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/set/transform.hpp.html b/doc/headers/set/transform.hpp.html new file mode 100644 index 0000000..c104193 --- /dev/null +++ b/doc/headers/set/transform.hpp.html @@ -0,0 +1,20 @@ + + + set/transform.hpp + + + +
    + The set/transform.hpp header defines macros to transform a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/set/transform.hpp> +
    +

    Contents

    + + + diff --git a/doc/headers/tuple/rem.hpp.html b/doc/headers/tuple/rem.hpp.html index 996dd0f..61bb24c 100644 --- a/doc/headers/tuple/rem.hpp.html +++ b/doc/headers/tuple/rem.hpp.html @@ -14,6 +14,7 @@

    Contents

    diff --git a/doc/headers/tuple/to_set.hpp.html b/doc/headers/tuple/to_set.hpp.html new file mode 100644 index 0000000..bdd0e42 --- /dev/null +++ b/doc/headers/tuple/to_set.hpp.html @@ -0,0 +1,19 @@ + + + tuple/to_set.hpp + + + +
    + The tuple/to_set.hpp header defines a macro that converts a tuple to a set. +
    +

    Usage

    +
    + #include <boost/preprocessor/tuple/to_set.hpp> +
    +

    Contents

    + + + diff --git a/doc/ref.html b/doc/ref.html index b7c73ae..064f6d5 100644 --- a/doc/ref.html +++ b/doc/ref.html @@ -117,6 +117,7 @@
  • LIMIT_ITERATION_DIM
  • LIMIT_MAG
  • LIMIT_REPEAT
    • +
  • LIMIT_SET
  • LIMIT_SLOT_COUNT
  • LIMIT_SLOT_SIG
  • LIMIT_TUPLE
    • @@ -208,6 +209,42 @@
  • RPAREN
  • RPAREN_IF
    • +
  • SET_CAT
    • +
  • SET_CAT_S
    • +
  • SET_ELEM
    • +
  • SET_ENUM
    • +
  • SET_FILTER
    • +
  • SET_FILTER_S
    • +
  • SET_FIRST_N
    • +
  • SET_FOLD_LEFT
    • +
  • SET_FOLD_LEFT_s
    • +
  • SET_FOLD_RIGHT
    • +
  • SET_FOLD_RIGHT_s
    • +
  • SET_FOR_EACH
    • +
  • SET_FOR_EACH_I
    • +
  • SET_FOR_EACH_I_R
    • +
  • SET_FOR_EACH_PRODUCT
    • +
  • SET_FOR_EACH_PRODUCT_R
    • +
  • SET_FOR_EACH_R
    • +
  • SET_HEAD
    • +
  • SET_INSERT
    • +
  • SET_NIL
    • +
  • SET_POP_BACK
    • +
  • SET_POP_FRONT
    • +
  • SET_PUSH_BACK
    • +
  • SET_PUSH_FRONT
    • +
  • SET_REMOVE
    • +
  • SET_REPLACE
    • +
  • SET_REST_N
    • +
  • SET_REVERSE
    • +
  • SET_REVERSE_S
    • +
  • SET_SIZE
    • +
  • SET_SUBSET
    • +
  • SET_TAIL
    • +
  • SET_TO_ARRAY
    • +
  • SET_TO_TUPLE
    • +
  • SET_TRANSFORM
    • +
  • SET_TRANSFORM_S
  • SLOT
  • STRINGIZE
  • SUB
    • @@ -216,8 +253,10 @@
  • TUPLE_EAT
  • TUPLE_ELEM
  • TUPLE_REM
    • +
  • TUPLE_REM_CTOR
  • TUPLE_REVERSE
  • TUPLE_TO_LIST
    • +
  • TUPLE_TO_SET
  • VALUE
    • diff --git a/doc/ref/limit_set.html b/doc/ref/limit_set.html new file mode 100644 index 0000000..beff5fa --- /dev/null +++ b/doc/ref/limit_set.html @@ -0,0 +1,23 @@ + + + BOOST_PP_LIMIT_SET + + + +
    + The BOOST_PP_LIMIT_SET macro defines the maximum set size supported by the library. +
    +

    Usage

    +
    + BOOST_PP_LIMIT_SET +
    +

    Remarks

    +
    + This macro currently expands to 256. +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/config/limits.hpp> +
    + + diff --git a/doc/ref/list_for_each_i.html b/doc/ref/list_for_each_i.html index 99a5464..75f78e1 100644 --- a/doc/ref/list_for_each_i.html +++ b/doc/ref/list_for_each_i.html @@ -16,7 +16,7 @@
    macro
    A macro of the form macro(r, data, i, elem).  - This macro is expanded by BOOST_PP_LIST_FOR_EACH with each element in list.  + This macro is expanded by BOOST_PP_LIST_FOR_EACH_I with each element in list.  It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, the index of the current element, and the current element.
    data
    diff --git a/doc/ref/set_cat.html b/doc/ref/set_cat.html new file mode 100644 index 0000000..a1b73fb --- /dev/null +++ b/doc/ref/set_cat.html @@ -0,0 +1,45 @@ + + + BOOST_PP_SET_CAT + + + +
    + The BOOST_PP_SET_CAT macro concatenates all elements in a set. +
    +

    Usage

    +
    + BOOST_PP_SET_CAT(list) +
    +

    Arguments

    +
    +
    set
    +
    + The set whose elements are to be concatenated. +
    +
    +

    Remarks

    +
    + Elements are concatenated left-to-right starting with index 0. +
    +
    + For maximum efficiency, use BOOST_PP_SET_CAT_S. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/cat.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/cat.hpp>
+
+#define SET (a)(b)(c)
+
+BOOST_PP_SET_CAT(SET) // expands to abc
+
    + + diff --git a/doc/ref/set_cat_s.html b/doc/ref/set_cat_s.html new file mode 100644 index 0000000..79300d0 --- /dev/null +++ b/doc/ref/set_cat_s.html @@ -0,0 +1,39 @@ + + + BOOST_PP_SET_CAT_S + + + +
    + The BOOST_PP_SET_CAT_S macro concatenates all elements in a set.  + It reenters BOOST_PP_SET_FOLD_LEFT with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_CAT_S(s, list) +
    +

    Arguments

    +
    +
    s
    +
    + The next available BOOST_PP_SET_FOLD_LEFT fold step. +
    +
    set
    +
    + The set whose elements are to be concatenated. +
    +
    +

    Remarks

    +
    + Elements are concatenated left-to-right starting with index 0. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/cat.hpp> +
    + + diff --git a/doc/ref/set_elem.html b/doc/ref/set_elem.html new file mode 100644 index 0000000..4653c9f --- /dev/null +++ b/doc/ref/set_elem.html @@ -0,0 +1,55 @@ + + + BOOST_PP_SET_ELEM + + + +
    + The BOOST_PP_SET_ELEM macro extracts an element from a set. +
    +

    Usage

    +
    + BOOST_PP_SET_ELEM(i, list) +
    +

    Arguments

    +
    +
    i
    +
    + The zero-based index of the element to be extracted. +
    +
    set
    +
    + The set from which an element is to be extracted. +
    +
    +

    Remarks

    +
    + The index i must be in the range of 0 to BOOST_PP_SET_SIZE(set) - 1. +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/elem.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/elem.hpp>
+
+BOOST_PP_SET_ELEM(1, (a)(b)(c)) // expands to b
+
+#define SET \
+   (0)(1)(2)(3)(4)(5)(6)(7)(8)(9) \
+   (10)(11)(12)(13)(14)(15)(16)(17)(18)(19) \
+   (20)(21)(22)(23)(24)(25)(26)(27)(28)(29) \
+   (30)(31)(32)(33)(34)(35)(36)(37)(38)(39) \
+   (40)(41)(42)(43)(44)(45)(46)(47)(48)(49) \
+   (50)(51)(52)(53)(54)(55)(56)(57)(58)(59) \
+   (60)(61)(62)(63)(64)(65)(66)(67)(68)(69) \
+   (70)(71)(72)(73)(74)(75)(76)(77)(78)(79) \
+   (80)(81)(82)(83)(84)(85)(86)(87)(88)(89) \
+   (90)(91)(92)(93)(94)(95)(96)(97)(98)(99) \
+   /**/
+
+BOOST_PP_SET_ELEM(88, SET) // expands to 88
+
    + + diff --git a/doc/ref/set_enum.html b/doc/ref/set_enum.html new file mode 100644 index 0000000..39a7b7e --- /dev/null +++ b/doc/ref/set_enum.html @@ -0,0 +1,42 @@ + + + BOOST_PP_SET_ENUM + + + +
    + The BOOST_PP_SET_ENUM macro enumerates the elements in a set. +
    +

    Usage

    +
    + BOOST_PP_SET_ENUM(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set from whose elements are to be enumerated. +
    +
    +

    Remarks

    +
    + This macro expands to a comma-separated list of the elements in set.  + For example, BOOST_PP_SET_ENUM((x)(y)(z)) expands to... +
    + x, y, z +
    +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/enum.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/enum.hpp>
+
+#define SET (B)(O)(O)(S)(T)
+
+BOOST_PP_SET_ENUM(SET) // expands to B, O, O, S, T
+
    + + diff --git a/doc/ref/set_filter.html b/doc/ref/set_filter.html new file mode 100644 index 0000000..d381d2e --- /dev/null +++ b/doc/ref/set_filter.html @@ -0,0 +1,63 @@ + + + BOOST_PP_SET_FILTER + + + +
    + The BOOST_PP_SET_FILTER macro filters a set according to a supplied criterion. +
    +

    Usage

    +
    + BOOST_PP_SET_FILTER(pred, data, set) +
    +

    Arguments

    +
    +
    pred
    +
    + A ternary predicate of the form pred(s, data, elem).  + This predicate is expanded by BOOST_PP_SET_FILTER for each element in set with the next available BOOST_PP_SET_FOLD_LEFT fold step, + the auxiliary data, and the current element in set.  + This macro must return a integral value in the range of 0 to BOOST_PP_LIMIT_MAG.  + If this predicate expands to non-zero for a certain element, that element is included in the resulting set. +
    +
    data
    +
    + Auxiliary data passed to pred. +
    +
    set
    +
    + The set to be filtered. +
    +
    +

    Remarks

    +
    + This macro expands pred for each element in set.  + It builds a new set out of each element for which pred returns non-zero. +
    +
    + For maximum efficiency, use BOOST_PP_SET_FILTER_S. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/filter.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/comparison/less_equal.hpp>
+#include <boost/preprocessor/set/filter.hpp>
+
+#define SET (1)(3)(2)(5)
+
+#define PRED(s, data, elem) BOOST_PP_LESS_EQUAL(elem, data)
+
+BOOST_PP_SET_FILTER(PRED, 3, SET)
+   // expands to (1)(3)(2)
+
    + + diff --git a/doc/ref/set_filter_s.html b/doc/ref/set_filter_s.html new file mode 100644 index 0000000..02b1cc7 --- /dev/null +++ b/doc/ref/set_filter_s.html @@ -0,0 +1,53 @@ + + + BOOST_PP_SET_FILTER_S + + + +
    + The BOOST_PP_SET_FILTER_S macro filters a set according to a supplied criterion.  + It reenters BOOST_PP_SET_FOLD_LEFT with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_FILTER_S(s, pred, data, set) +
    +

    Arguments

    +
    +
    s
    +
    + The next available BOOST_PP_SET_FOLD_LEFT fold step. +
    +
    pred
    +
    + A ternary predicate of the form pred(s, data, elem).  + This predicate is expanded by BOOST_PP_SET_FILTER for each element in set with the next available BOOST_PP_SET_FOLD_LEFT fold step, + the auxiliary data, and the current element in set.  + This macro must return a integral value in the range of 0 to BOOST_PP_LIMIT_MAG.  + If this predicate expands to non-zero for a certain element, that element is included in the resulting set. +
    +
    data
    +
    + Auxiliary data passed to pred. +
    +
    set
    +
    + The set to be filtered. +
    +
    +

    Remarks

    +
    + This macro expands pred for each element in set.  + It builds a new set out of each element for which pred returns non-zero. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/filter.hpp> +
    + + diff --git a/doc/ref/set_first_n.html b/doc/ref/set_first_n.html new file mode 100644 index 0000000..2c73099 --- /dev/null +++ b/doc/ref/set_first_n.html @@ -0,0 +1,46 @@ + + + BOOST_PP_SET_FIRST_N + + + +
    + The BOOST_PP_SET_FIRST_N macro expands to a set of the first n elements of a set. +
    +

    Usage

    +
    + BOOST_PP_SET_FIRST_N(n, list) +
    +

    Arguments

    +
    +
    n
    +
    + The number of elements to extract. +
    +
    list
    +
    + The set from which the elements are extracted. +
    +
    +

    Remarks

    +
    + This macro extracts n elements from the beginning of set and returns them as a new set +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/first_n.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/first_n.hpp>
+
+#define SET (a)(b)(c)(d)(e)
+
+BOOST_PP_SET_FIRST_N(2, SET) // expands to (a)(b)
+
    + + diff --git a/doc/ref/set_fold_left.html b/doc/ref/set_fold_left.html new file mode 100644 index 0000000..b339f51 --- /dev/null +++ b/doc/ref/set_fold_left.html @@ -0,0 +1,62 @@ + + + BOOST_PP_SET_FOLD_LEFT + + + +
    + The BOOST_PP_SET_FOLD_LEFT macro folds (or accumulates) the elements of a set left-to-right. +
    +

    Usage

    +
    + BOOST_PP_SET_FOLD_LEFT(op, state, set) +
    +

    Arguments

    +
    +
    op
    +
    + A ternary operation of the form op(s, state, elem).  + This macro is called for each element in set--each time returning a new state.  + This operation is expanded by BOOST_PP_SET_FOLD_LEFT with the next available fold step, + the current state, and the current element. +
    +
    state
    +
    + The initial state of the fold. +
    +
    set
    +
    + The set to be folded. +
    +
    +

    Remarks

    +
    + For the set, (0)(1)(2), this macro expands to: +
    + op(s, op(s, op(s, state, 0), 1), 2) +
    +
    +
    + For maximum efficiency, BOOST_PP_SET_FOLD_LEFT can be reentered with BOOST_PP_SET_FOLD_LEFT_s. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/fold_left.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/set/fold_left.hpp>
+
+#define SET (b)(o)(o)(s)(t)
+
+#define OP(s, state, x) BOOST_PP_CAT(state, x)
+
+BOOST_PP_SET_FOLD_LEFT(OP, BOOST_PP_SET_HEAD(SET), BOOST_PP_SET_TAIL(SET)) // expands to boost
+
    + + diff --git a/doc/ref/set_fold_left_s.html b/doc/ref/set_fold_left_s.html new file mode 100644 index 0000000..002bad2 --- /dev/null +++ b/doc/ref/set_fold_left_s.html @@ -0,0 +1,68 @@ + + + BOOST_PP_SET_FOLD_LEFT_s + + + +
    + The BOOST_PP_SET_FOLD_LEFT_s macro folds (or accumulates) the elements of a set left-to-right.  + It reenters BOOST_PP_SET_FOLD_LEFT with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_FOLD_LEFT_ ## s(op, state, set) +
    +

    Arguments

    +
    +
    s
    +
    + The next available BOOST_PP_SET_FOLD_LEFT fold step. +
    +
    op
    +
    + A ternary operation of the form op(s, state, elem).  + This macro is called for each element in set--each time returning a new state.  + This operation is expanded by BOOST_PP_SET_FOLD_LEFT with the next available fold step, + the current state, and the current element. +
    +
    state
    +
    + The initial state of the fold. +
    +
    set
    +
    + The set to be folded. +
    +
    +

    Remarks

    +
    + For the set, (0)(1)(2), this macro expands to: +
    + op(s, op(s, op(s, state, 0), 1), 2) +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/fold_left.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/set/fold_left.hpp>
+#include <boost/preprocessor/set/set.hpp>
+
+#define S1 (a)(b)(c)
+#define S2 (S1)(S1)(S1)
+
+#define OP(s, state, x) state (BOOST_PP_SET_FOLD_LEFT_ ## s(OP_2, _, x))
+#define OP_2(s, state, x) BOOST_PP_CAT(state, x)
+
+BOOST_PP_SET_FOLD_LEFT(OP, BOOST_PP_SET_NIL, S2)
+// expands to (_abc)(_abc)(_abc)
+
    + + diff --git a/doc/ref/set_fold_right.html b/doc/ref/set_fold_right.html new file mode 100644 index 0000000..da56135 --- /dev/null +++ b/doc/ref/set_fold_right.html @@ -0,0 +1,64 @@ + + + BOOST_PP_SET_FOLD_RIGHT + + + +
    + The BOOST_PP_SET_FOLD_RIGHT macro folds (or accumulates) the elements of a set right-to-left. +
    +

    Usage

    +
    + BOOST_PP_SET_FOLD_RIGHT(op, state, set) +
    +

    Arguments

    +
    +
    op
    +
    + A ternary operation of the form op(s, state, elem).  + This macro is called for each element in set--each time returning a new state.  + This operation is expanded by BOOST_PP_SET_FOLD_RIGHT with the next available fold step, + the current state, and the current element. +
    +
    state
    +
    + The initial state of the fold. +
    +
    set
    +
    + The set to be folded. +
    +
    +

    Remarks

    +
    + For the set, (0)(1)(2), this macro expands to: +
    + op(s, op(s, op(s, state, 2), 1), 0) +
    +
    +
    + For maximum efficiency, BOOST_PP_SET_FOLD_RIGHT can be reentered with BOOST_PP_SET_FOLD_RIGHT_s. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/fold_right.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/set/elem.hpp>
+#include <boost/preprocessor/set/fold_right.hpp>
+#include <boost/preprocessor/set/pop_back.hpp>
+
+#define SET (t)(s)(o)(o)(b)
+
+#define OP(s, state, x) BOOST_PP_CAT(state, x)
+
+BOOST_PP_SET_FOLD_RIGHT(OP, BOOST_PP_SET_ELEM(4, SET), BOOST_PP_SET_POP_BACK(SET)) // expands to boost
+
    + + diff --git a/doc/ref/set_fold_right_s.html b/doc/ref/set_fold_right_s.html new file mode 100644 index 0000000..aa7607c --- /dev/null +++ b/doc/ref/set_fold_right_s.html @@ -0,0 +1,69 @@ + + + BOOST_PP_SET_FOLD_RIGHT_s + + + +
    + The BOOST_PP_SET_FOLD_RIGHT_s macro folds (or accumulates) the elements of a set right-to-left.  + It reenters BOOST_PP_SET_FOLD_RIGHT with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_FOLD_RIGHT_ ## s(op, state, set) +
    +

    Arguments

    +
    +
    s
    +
    + The next available BOOST_PP_SET_FOLD_LEFT fold step. +
    +
    op
    +
    + A ternary operation of the form op(s, state, elem).  + This macro is called for each element in set--each time returning a new state.  + This operation is expanded by BOOST_PP_SET_FOLD_RIGHT with the next available fold step, + the current state, and the current element. +
    +
    state
    +
    + The initial state of the fold. +
    +
    set
    +
    + The set to be folded. +
    +
    +

    Remarks

    +
    + For the set, (0)(1)(2), this macro expands to: +
    + op(s, op(s, op(s, state, 2), 1), 0) +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/fold_right.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/set/fold_left.hpp>
+#include <boost/preprocessor/set/fold_right.hpp>
+#include <boost/preprocessor/set/set.hpp>
+
+#define S1 (a)(b)(c)
+#define S2 (S1)(S1)(S1)
+
+#define OP(s, state, x) state (BOOST_PP_SET_FOLD_RIGHT_ ## s(OP_2, _, x))
+#define OP_2(s, state, x) BOOST_PP_CAT(state, x)
+
+BOOST_PP_SET_FOLD_LEFT(OP, BOOST_PP_SET_NIL, S2)
+// expands to (_cba)(_cba)(_cba)
+
    + + diff --git a/doc/ref/set_for_each.html b/doc/ref/set_for_each.html new file mode 100644 index 0000000..37d0573 --- /dev/null +++ b/doc/ref/set_for_each.html @@ -0,0 +1,62 @@ + + + BOOST_PP_SET_FOR_EACH + + + +
    + The BOOST_PP_SET_FOR_EACH macro repeats a macro for each element in a set. +
    +

    Usage

    +
    + BOOST_PP_SET_FOR_EACH(macro, data, set) +
    +

    Arguments

    +
    +
    macro
    +
    + A ternary macro of the form macro(r, data, elem).  + This macro is expanded by BOOST_PP_SET_FOR_EACH with each element in set.  + It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, and the current element. +
    +
    data
    +
    + Auxiliary data passed to macro. +
    +
    set
    +
    + The set for which macro will be invoked on each element. +
    +
    +

    Remarks

    +
    + This macro is a repetition construct.  + If set is (a)(b)(c), it expands to the sequence: +
    + macro(r, data, a) macro(r, data, b) macro(r, data, c) +
    +
    +
    + For maximum efficiency, use BOOST_PP_SET_FOR_EACH_R. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/for_each.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/set/for_each.hpp>
+
+#define SET (w)(x)(y)(z)
+
+#define MACRO(r, data, elem) BOOST_PP_CAT(elem, data)
+
+BOOST_PP_SET_FOR_EACH(MACRO, _, SET) // expands to w_ x_ y_ z_
+
    + + diff --git a/doc/ref/set_for_each_i.html b/doc/ref/set_for_each_i.html new file mode 100644 index 0000000..cad16e4 --- /dev/null +++ b/doc/ref/set_for_each_i.html @@ -0,0 +1,62 @@ + + + BOOST_PP_SET_FOR_EACH_I + + + +
    + The BOOST_PP_SET_FOR_EACH_I macro repeats a macro for each element in a set. +
    +

    Usage

    +
    + BOOST_PP_SET_FOR_EACH_I(macro, data, set) +
    +

    Arguments

    +
    +
    macro
    +
    + A macro of the form macro(r, data, i, elem).  + This macro is expanded by BOOST_PP_SET_FOR_EACH_I with each element in set.  + It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, the index of the current element, and the current element. +
    +
    data
    +
    + Auxiliary data passed to macro. +
    +
    set
    +
    + The set for which macro will be invoked on each element. +
    +
    +

    Remarks

    +
    + This macro is a repetition construct.  + If set is (a)(b)(c), it expands to the sequence: +
    + macro(r, data, 0, a) macro(r, data, 1, b) macro(r, data, 2, c) +
    +
    +
    + For maximum efficiency, use BOOST_PP_SET_FOR_EACH_I_R +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/for_each_i.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/set/for_each_i.hpp>
+
+#define SET (a)(b)(c)(d)
+
+#define MACRO(r, data, i, elem) BOOST_PP_CAT(elem, BOOST_PP_CAT(data, i))
+
+BOOST_PP_SET_FOR_EACH_I(MACRO, _, SET) // expands to a_0 b_1 c_2 d_3
+
    + + diff --git a/doc/ref/set_for_each_i_r.html b/doc/ref/set_for_each_i_r.html new file mode 100644 index 0000000..2ae499e --- /dev/null +++ b/doc/ref/set_for_each_i_r.html @@ -0,0 +1,53 @@ + + + BOOST_PP_SET_FOR_EACH_I_R + + + +
    + The BOOST_PP_SET_FOR_EACH_I_R macro repeats a macro for each element in a set.  + It reenters BOOST_PP_FOR with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_FOR_EACH_I_R(r, macro, data, set) +
    +

    Arguments

    +
    +
    r
    +
    + The next available BOOST_PP_FOR repetition. +
    +
    macro
    +
    + A macro of the form macro(r, data, i, elem).  + This macro is expanded by BOOST_PP_SET_FOR_EACH_I with each element in set.  + It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, the index of the current element, and the current element. +
    +
    data
    +
    + Auxiliary data passed to macro. +
    +
    set
    +
    + The set for which macro will be invoked on each element. +
    +
    +

    Remarks

    +
    + This macro is a repetition construct.  + If set is (a)(b)(c), it expands to the sequence: +
    + macro(r, data, 0, a) macro(r, data, 1, b) macro(r, data, 2, c) +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/for_each_i.hpp> +
    + + diff --git a/doc/ref/set_for_each_product.html b/doc/ref/set_for_each_product.html new file mode 100644 index 0000000..a836314 --- /dev/null +++ b/doc/ref/set_for_each_product.html @@ -0,0 +1,73 @@ + + + BOOST_PP_SET_FOR_EACH_PRODUCT + + + +
    + The BOOST_PP_SET_FOR_EACH_PRODUCT macro repeats a macro for each cartesian product of several sets. +
    +

    Usage

    +
    + BOOST_PP_SET_FOR_EACH_PRODUCT(macro, sets) +
    +

    Arguments

    +
    +
    macro
    +
    + The binary macro of the form macro(r, product).  + This macro is expanded by BOOST_PP_FOR_EACH_PRODUCT with each cartesian product in sets.  + It is expanded with the next available BOOST_PP_FOR repetition and a set containing a cartesian product.  +
    +
    sets
    +
    + A set of sets from which cartesian products are obtained. +
    +
    +

    Remarks

    +
    + This macro is a repetition construct.  + If two sets are (a)(b)(c) and (x)(y)(z), + this macro will produce the following sequence: +
    + macro(r, (a)(x)) + macro(r, (a)(y)) + macro(r, (a)(z)) \
    + macro(r, (b)(x)) + macro(r, (b)(y)) + macro(r, (b)(z)) \
    + macro(r, (c)(x)) + macro(r, (c)(y)) + macro(r, (c)(z)) +
    +
    +
    + For maximum efficiency, use BOOST_PP_SET_FOR_EACH_PRODUCT_R. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/for_each_product.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/for_each_product.hpp>
+#include <boost/preprocessor/set/to_tuple.hpp>
+
+#define S1 (a)(b)(c)
+#define S2 (x)(y)(z)
+#define S3 (p)(q)
+
+#define MACRO(r, product) BOOST_PP_SET_TO_TUPLE(product)
+
+BOOST_PP_SET_FOR_EACH_PRODUCT(MACRO, (S1)(S2)(S3))
+   // expands to:
+   //   (a, x, p) (a, x, q) (a, y, p) (a, y, q) (a, z, p) (a, z, q)
+   //   (b, x, p) (b, x, q) (b, y, p) (b, y, q) (b, z, p) (b, z, q)
+   //   (c, x, p) (c, x, q) (c, y, p) (c, y, q) (c, z, p) (c, z, q)
+
    + + diff --git a/doc/ref/set_for_each_product_r.html b/doc/ref/set_for_each_product_r.html new file mode 100644 index 0000000..df65d36 --- /dev/null +++ b/doc/ref/set_for_each_product_r.html @@ -0,0 +1,58 @@ + + + BOOST_PP_SET_FOR_EACH_PRODUCT_R + + + +
    + The BOOST_PP_SET_FOR_EACH_PRODUCT_R macro repeats a macro for each cartesian product of several sets.  + It reenters BOOST_PP_FOR with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_FOR_EACH_PRODUCT_R(r, macro, sets) +
    +

    Arguments

    +
    +
    r
    +
    + The next available BOOST_PP_FOR repetition. +
    +
    macro
    +
    + The binary macro of the form macro(r, product).  + This macro is expanded by BOOST_PP_FOR_EACH_PRODUCT with each cartesian product in sets.  + It is expanded with the next available BOOST_PP_FOR repetition and a set containing a cartesian product.  +
    +
    sets
    +
    + A set of sets from which cartesian products are obtained. +
    +
    +

    Remarks

    +
    + This macro is a repetition construct.  + If two sets are (a)(b)(c) and (x)(y)(z), + this macro will produce the following sequence: +
    + macro(r, (a)(x)) + macro(r, (a)(y)) + macro(r, (a)(z)) \
    + macro(r, (b)(x)) + macro(r, (b)(y)) + macro(r, (b)(z)) \
    + macro(r, (c)(x)) + macro(r, (c)(y)) + macro(r, (c)(z)) +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/for_each_product.hpp> +
    + + diff --git a/doc/ref/set_for_each_r.html b/doc/ref/set_for_each_r.html new file mode 100644 index 0000000..de600f9 --- /dev/null +++ b/doc/ref/set_for_each_r.html @@ -0,0 +1,53 @@ + + + BOOST_PP_SET_FOR_EACH_R + + + +
    + The BOOST_PP_SET_FOR_EACH_R macro repeats a macro for each element in a set.  + It reenters BOOST_PP_FOR with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_FOR_EACH_R(r, macro, data, set) +
    +

    Arguments

    +
    +
    r
    +
    + The next available BOOST_PP_FOR repetition. +
    +
    macro
    +
    + A ternary macro of the form macro(r, data, elem).  + This macro is expanded by BOOST_PP_SET_FOR_EACH with each element in set.  + It is expanded with the next available BOOST_PP_FOR repetition, the auxiliary data, and the current element. +
    +
    data
    +
    + Auxiliary data passed to macro. +
    +
    set
    +
    + The set for which macro will be invoked on each element. +
    +
    +

    Remarks

    +
    + This macro is a repetition construct.  + If set is (a)(b)(c), it expands to the sequence: +
    + macro(r, data, a) macro(r, data, b) macro(r, data, c) +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/for_each.hpp> +
    + + diff --git a/doc/ref/set_head.html b/doc/ref/set_head.html new file mode 100644 index 0000000..9cfac73 --- /dev/null +++ b/doc/ref/set_head.html @@ -0,0 +1,39 @@ + + + BOOST_PP_SET_HEAD + + + +
    + The BOOST_PP_SET_HEAD macro expands to the first element in a set. +
    +

    Usage

    +
    + BOOST_PP_SET_HEAD(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set from which the first element is extracted. +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/set.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/set.hpp>
+
+#define SET (a)(b)(c)
+
+BOOST_PP_SET_HEAD(SET) // expands to a
+BOOST_PP_SET_TAIL(SET) // expands to (b)(c)
+
    + + diff --git a/doc/ref/set_insert.html b/doc/ref/set_insert.html new file mode 100644 index 0000000..7731f0d --- /dev/null +++ b/doc/ref/set_insert.html @@ -0,0 +1,47 @@ + + + BOOST_PP_SET_INSERT + + + +
    + The BOOST_PP_SET_INSERT macro inserts an element into an set. +
    +

    Usage

    +
    + BOOST_PP_SET_INSERT(set, i, elem) +
    +

    Arguments

    +
    +
    set
    +
    + The set into which an element is to be inserted. +
    +
    i
    +
    + The zero-based position in set where an element is to be inserted.  + Valid values range from 0 to BOOST_PP_SET_SIZE(set) - 1. +
    +
    elem
    +
    + The element to insert. +
    +
    +

    Remarks

    +
    + This macro inserts elem before the element at index i. +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/insert.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/insert.hpp>
+
+#define SET (a)(b)(d)
+
+BOOST_PP_SET_INSERT(SET, 2, c) // expands to (a)(b)(c)(d)
+
    + + diff --git a/doc/ref/set_nil.html b/doc/ref/set_nil.html new file mode 100644 index 0000000..11ee413 --- /dev/null +++ b/doc/ref/set_nil.html @@ -0,0 +1,69 @@ + + + BOOST_PP_SET_NIL + + + +
    + The BOOST_PP_SET_NIL macro is a placeholder macro for an empty set.  + It is only valid if it is elements are appended to the end of this empty "set."  +
    +

    Usage

    +
    + BOOST_PP_SET_NIL +
    +

    Remarks

    +
    + This macro is a utility macro intended as a empty starting point for appending to the tail.  + It is not a nil set.  + When an element is appended to this macro, it expands on the element and to the element--thereby removing itself.  + For example, both BOOST_PP_SET_NIL(x) + and BOOST_PP_SET_PUSH_BACK(BOOST_PP_SET_NIL, x) expand to x. +
    +
    + If any BOOST_PP_SET_* macro (other than BOOST_PP_SET_PUSH_BACK) is invoked with an argument that contains BOOST_PP_SET_NIL, + the behavior is undefined and in most cases will result in obscure errors. +
    +
    + The closest thing available to BOOST_PP_SET_NIL for appending to the head is BOOST_PP_EMPTY.  + After all the elements have been prepended, empty parenthesis can be invoked on the tail to remove the BOOST_PP_EMPTY.  + As with BOOST_PP_SET_NIL, passing an argument that contains BOOST_PP_EMPTY to any BOOST_PP_SET_* macro (other than BOOST_PP_SET_PUSH_FRONT) is undefined.  +
    +
    + (It is also possible to start with an extra element and pop it off when you have finished appending to it.) +
    +
    + In C99, neither of these macros are necessary since it is legal to pass empty arguments. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/set.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/set/push_back.hpp>
+#include <boost/preprocessor/set/push_front.hpp>
+#include <boost/preprocessor/set/set.hpp>
+
+#define SET_L BOOST_PP_SET_NIL
+#define SET_R BOOST_PP_EMPTY
+
+BOOST_PP_SET_PUSH_BACK(
+   BOOST_PP_SET_PUSH_BACK(SET_L, a), b
+)
+
+// expands to (a)(b)
+
+BOOST_PP_SET_PUSH_FRONT(
+   BOOST_PP_SET_PUSH_FRONT(SET_R, a), b
+)()
+
+// expands to (b)(a)
+
    + + diff --git a/doc/ref/set_pop_back.html b/doc/ref/set_pop_back.html new file mode 100644 index 0000000..1f00277 --- /dev/null +++ b/doc/ref/set_pop_back.html @@ -0,0 +1,42 @@ + + + BOOST_PP_SET_POP_BACK + + + +
    + The BOOST_PP_SET_POP_BACK macro pops an element from the end of a set. +
    +

    Usage

    +
    + BOOST_PP_SET_POP_BACK(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set to pop an element from. +
    +
    +

    Remarks

    +
    + This macro returns set after removing the last element.  +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/pop_back.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/pop_back.hpp>
+
+#define SET (a)(b)(c)
+
+BOOST_PP_SET_POP_BACK(SET) // expands to (a)(b)
+
    + + diff --git a/doc/ref/set_pop_front.html b/doc/ref/set_pop_front.html new file mode 100644 index 0000000..18a217a --- /dev/null +++ b/doc/ref/set_pop_front.html @@ -0,0 +1,42 @@ + + + BOOST_PP_SET_POP_FRONT + + + +
    + The BOOST_PP_SET_POP_FRONT macro pops an element from the beginning of a set. +
    +

    Usage

    +
    + BOOST_PP_SET_POP_FRONT(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set to pop an element from. +
    +
    +

    Remarks

    +
    + This macro returns set after removing the first element.  +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/pop_front.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/pop_front.hpp>
+
+#define SET (a)(b)(c)
+
+BOOST_PP_SET_POP_FRONT(SET) // expands to (b)(c)
+
    + + diff --git a/doc/ref/set_push_back.html b/doc/ref/set_push_back.html new file mode 100644 index 0000000..d2f1bb3 --- /dev/null +++ b/doc/ref/set_push_back.html @@ -0,0 +1,50 @@ + + + BOOST_PP_SET_PUSH_BACK + + + +
    + The BOOST_PP_SET_PUSH_BACK macro pushes an element onto the end of a set. +
    +

    Usage

    +
    + BOOST_PP_SET_PUSH_BACK(set, elem) +
    +

    Arguments

    +
    +
    set
    +
    + The set onto which elem is pushed. +
    +
    elem
    +
    + The element to push onto the end of set. +
    +
    +

    Remarks

    +
    + This macro returns set after appending elem.  +
    +
    + This macro is an explicit form of directly appending an element.  + In other words, BOOST_PP_SET_PUSH_BACK(set, x) is equivalent to set(x). +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/push_back.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/push_back.hpp>
+
+#define SET (a)(b)
+
+BOOST_PP_SET_PUSH_BACK(SET, c) // expands to (a)(b)(c)
+
    + + diff --git a/doc/ref/set_push_front.html b/doc/ref/set_push_front.html new file mode 100644 index 0000000..8518488 --- /dev/null +++ b/doc/ref/set_push_front.html @@ -0,0 +1,50 @@ + + + BOOST_PP_SET_PUSH_FRONT + + + +
    + The BOOST_PP_SET_PUSH_FRONT macro pushes an element onto the beginning of a set. +
    +

    Usage

    +
    + BOOST_PP_SET_PUSH_FRONT(set, elem) +
    +

    Arguments

    +
    +
    set
    +
    + The set onto which elem is pushed. +
    +
    elem
    +
    + The element to push onto the beginning of set. +
    +
    +

    Remarks

    +
    + This macro returns set after prepending elem.  +
    +
    + This macro is an explicit form of directly prepending an element.  + In other words, BOOST_PP_SET_PUSH_FRONT(set, x) is equivalent to (x)set. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/push_front.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/push_front.hpp>
+
+#define SET (b)(c)
+
+BOOST_PP_SET_PUSH_FRONT(SET, a) // expands to (a)(b)(c)
+
    + + diff --git a/doc/ref/set_remove.html b/doc/ref/set_remove.html new file mode 100644 index 0000000..4643316 --- /dev/null +++ b/doc/ref/set_remove.html @@ -0,0 +1,43 @@ + + + BOOST_PP_SET_REMOVE + + + +
    + The BOOST_PP_SET_REMOVE macro removes an element from a set. +
    +

    Usage

    +
    + BOOST_PP_SET_REMOVE(set, i) +
    +

    Arguments

    +
    +
    set
    +
    + The set from which an element is to be removed. +
    +
    i
    +
    + The zero-based position in set of the element to be removed.  + Valid values range from 0 to BOOST_PP_SET_SIZE(set) - 1. +
    +
    +

    Remarks

    +
    + This macro returns set after removing the element at index i. +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/remove.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/remove.hpp>
+
+#define SET (a)(b)(x)(c)
+
+BOOST_PP_SET_REMOVE(SET, 2) // expands to (a)(b)(c)
+
    + + diff --git a/doc/ref/set_replace.html b/doc/ref/set_replace.html new file mode 100644 index 0000000..d2281f4 --- /dev/null +++ b/doc/ref/set_replace.html @@ -0,0 +1,47 @@ + + + BOOST_PP_SET_REPLACE + + + +
    + The BOOST_PP_SET_REPLACE macro replaces an element in a set. +
    +

    Usage

    +
    + BOOST_PP_SET_RPLACE(set, i, elem) +
    +

    Arguments

    +
    +
    set
    +
    + The set in which an element is to be replaced. +
    +
    i
    +
    + The zero-based position in set of the element to be replaced.  + Valid values range from 0 to BOOST_PP_SET_SIZE(set) - 1. +
    +
    elem
    +
    + The element to replace the element at index i within set. +
    +
    +

    Remarks

    +
    + This macro returns set after replacing the element at index i with elem. +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/replace.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/replace.hpp>
+
+#define SET (a)(b)(x)(d)
+
+BOOST_PP_SET_REPLACE(SET, 2, c) // expands to (a)(b)(c)(d)
+
    + + diff --git a/doc/ref/set_rest_n.html b/doc/ref/set_rest_n.html new file mode 100644 index 0000000..58055f5 --- /dev/null +++ b/doc/ref/set_rest_n.html @@ -0,0 +1,92 @@ + + + BOOST_PP_SET_REST_N + + + +
    + The BOOST_PP_SET_REST_N macro expands to a set of all but the first n elements of a set. +
    +

    Usage

    +
    + BOOST_PP_SET_REST_N(n, list) +
    +

    Arguments

    +
    +
    n
    +
    + The number of elements to remove. +
    +
    list
    +
    + The set from which the elements are to be removed. +
    +
    +

    Remarks

    +
    + This macro extracts n elements from the beginning of set and returns the remainder of set as a new set +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/rest_n.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/set/elem.hpp>
+#include <boost/preprocessor/set/first_n.hpp>
+#include <boost/preprocessor/set/rest_n.hpp>
+#include <boost/preprocessor/set/size.hpp>
+
+#define NUMBERS \
+   (0)(1)(2)(3)(4)(5)(6)(7)(8)(9) \
+   (10)(11)(12)(13)(14)(15)(16)(17)(18)(19) \
+   (20)(21)(22)(23)(24)(25)(26)(27)(28)(29) \
+   (30)(31)(32)(33)(34)(35)(36)(37)(38)(39) \
+   (40)(41)(42)(43)(44)(45)(46)(47)(48)(49) \
+   (50)(51)(52)(53)(54)(55)(56)(57)(58)(59) \
+   (60)(61)(62)(63)(64)(65)(66)(67)(68)(69) \
+   (70)(71)(72)(73)(74)(75)(76)(77)(78)(79) \
+   (80)(81)(82)(83)(84)(85)(86)(87)(88)(89) \
+   (90)(91)(92)(93)(94)(95)(96)(97)(98)(99) \
+   (100)(101)(102)(103)(104)(105)(106)(107)(108)(109) \
+   (110)(111)(112)(113)(114)(115)(116)(117)(118)(119) \
+   (120)(121)(122)(123)(124)(125)(126)(127)(128)(129) \
+   (130)(131)(132)(133)(134)(135)(136)(137)(138)(139) \
+   (140)(141)(142)(143)(144)(145)(146)(147)(148)(149) \
+   (150)(151)(152)(153)(154)(155)(156)(157)(158)(159) \
+   (160)(161)(162)(163)(164)(165)(166)(167)(168)(169) \
+   (170)(171)(172)(173)(174)(175)(176)(177)(178)(179) \
+   (180)(181)(182)(183)(184)(185)(186)(187)(188)(189) \
+   (190)(191)(192)(193)(194)(195)(196)(197)(198)(199) \
+   (200)(201)(202)(203)(204)(205)(206)(207)(208)(209) \
+   (210)(211)(212)(213)(214)(215)(216)(217)(218)(219) \
+   (220)(221)(222)(223)(224)(225)(226)(227)(228)(229) \
+   (230)(231)(232)(233)(234)(235)(236)(237)(238)(239) \
+   (240)(241)(242)(243)(244)(245)(246)(247)(248)(249) \
+   (250)(251)(252)(253)(254)(255)(256) \
+   /**/
+
+#define SUPER_ADD(x, y) BOOST_PP_SET_ELEM(y, BOOST_PP_SET_REST_N(x, NUMBERS))
+
+SUPER_ADD(100, 100) // expands to 200
+
+#define SUPER_SUB(x, y) \
+   BOOST_PP_SET_SIZE( \
+      BOOST_PP_SET_REST_N( \
+         BOOST_PP_INC(y), \
+         BOOST_PP_SET_FIRST_N( \
+            BOOST_PP_INC(x), NUMBERS \
+         ) \
+      ) \
+   ) \
+   /**/
+
+SUPER_SUB(67, 25) // expands to 42
+
    + + diff --git a/doc/ref/set_reverse.html b/doc/ref/set_reverse.html new file mode 100644 index 0000000..07a8720 --- /dev/null +++ b/doc/ref/set_reverse.html @@ -0,0 +1,42 @@ + + + BOOST_PP_SET_REVERSE + + + +
    + The BOOST_PP_SET_REVERSE macro reverses a set. +
    +

    Usage

    +
    + BOOST_PP_SET_REVERSE(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set to be reversed. +
    +
    +

    Remarks

    +
    + For maximum efficiency, use BOOST_PP_SET_REVERSE_S. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/reverse.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/reverse.hpp>
+
+#define SET (1)(2)(3)
+
+BOOST_PP_SET_REVERSE(SET) // expands to (3)(2)(1)
+
    + + diff --git a/doc/ref/set_reverse_s.html b/doc/ref/set_reverse_s.html new file mode 100644 index 0000000..8c8736f --- /dev/null +++ b/doc/ref/set_reverse_s.html @@ -0,0 +1,35 @@ + + + BOOST_PP_SET_REVERSE_S + + + +
    + The BOOST_PP_SET_REVERSE_S macro reverses a set.  + It reenters BOOST_PP_SET_FOLD_LEFT with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_REVERSE_S(s, set) +
    +

    Arguments

    +
    +
    s
    +
    + The next available BOOST_PP_SET_FOLD_LEFT fold step. +
    +
    set
    +
    + The set to be reversed. +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/reverse.hpp> +
    + + diff --git a/doc/ref/set_size.html b/doc/ref/set_size.html new file mode 100644 index 0000000..ac0f54f --- /dev/null +++ b/doc/ref/set_size.html @@ -0,0 +1,34 @@ + + + BOOST_PP_SET_SIZE + + + +
    + The BOOST_PP_SET_SIZE macro expands to the size of a set. +
    +

    Usage

    +
    + BOOST_PP_SET_SIZE(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set whose size is to be calculated. +
    +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/size.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/size.hpp>
+
+#define SET (a)(b)(c)
+
+BOOST_PP_SET_SIZE(SET) // expands to 3
+
    + + diff --git a/doc/ref/set_subset.html b/doc/ref/set_subset.html new file mode 100644 index 0000000..a5b1a65 --- /dev/null +++ b/doc/ref/set_subset.html @@ -0,0 +1,46 @@ + + + BOOST_PP_SET_SUBSET + + + +
    + The BOOST_PP_SET_SUBSET macro expands to a subset of elements in a set. +
    +

    Usage

    +
    + BOOST_PP_SET_SUBSET(set, i, len) +
    +

    Arguments

    +
    +
    set
    +
    + The set whose size is to be calculated. +
    +
    i
    +
    + The index of the first element of the subset to be extracted. +
    +
    len
    +
    + The length of the subset to be extracted. +
    +
    +

    Remarks

    +
    + This macro expands to a set extracted from set. +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/subset.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/subset.hpp>
+
+#define SET (0)(1)(2)(3)(4)(5)
+
+BOOST_PP_SET_SUBSET(SET, 2, 3) // expands to (2)(3)(4)
+
    + + diff --git a/doc/ref/set_tail.html b/doc/ref/set_tail.html new file mode 100644 index 0000000..9c742e2 --- /dev/null +++ b/doc/ref/set_tail.html @@ -0,0 +1,39 @@ + + + BOOST_PP_SET_TAIL + + + +
    + The BOOST_PP_SET_HEAD macro expands to all but the first element of a set. +
    +

    Usage

    +
    + BOOST_PP_SET_TAIL(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set from which the tail is extracted. +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/set.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/set.hpp>
+
+#define SET (a)(b)(c)
+
+BOOST_PP_SET_HEAD(SET) // expands to a
+BOOST_PP_SET_TAIL(SET) // expands to (b)(c)
+
    + + diff --git a/doc/ref/set_to_array.html b/doc/ref/set_to_array.html new file mode 100644 index 0000000..2643136 --- /dev/null +++ b/doc/ref/set_to_array.html @@ -0,0 +1,34 @@ + + + BOOST_PP_SET_TO_ARRAY + + + +
    + The BOOST_PP_SET_TO_ARRAY macro converts a set to an array. +
    +

    Usage

    +
    + BOOST_PP_SET_TO_ARRAY(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set to be converted. +
    +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/to_array.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/to_array.hpp>
+
+#define SET (a)(b)(c)
+
+BOOST_PP_SET_TO_ARRAY(SET) // expands to (3, (a, b, c))
+
    + + diff --git a/doc/ref/set_to_tuple.html b/doc/ref/set_to_tuple.html new file mode 100644 index 0000000..1210886 --- /dev/null +++ b/doc/ref/set_to_tuple.html @@ -0,0 +1,34 @@ + + + BOOST_PP_SET_TO_TUPLE + + + +
    + The BOOST_PP_SET_TO_TUPLE macro converts a set to an tuple. +
    +

    Usage

    +
    + BOOST_PP_SET_TO_TUPLE(set) +
    +

    Arguments

    +
    +
    set
    +
    + The set to be converted. +
    +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/set/to_tuple.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/set/to_tuple.hpp>
+
+#define SET (a)(b)(c)
+
+BOOST_PP_SET_TO_TUPLE(SET) // expands to (a, b, c)
+
    + + diff --git a/doc/ref/set_transform.html b/doc/ref/set_transform.html new file mode 100644 index 0000000..2fad2bb --- /dev/null +++ b/doc/ref/set_transform.html @@ -0,0 +1,65 @@ + + + BOOST_PP_SET_TRANSFORM + + + +
    + The BOOST_PP_SET_TRANSFORM macro transforms each element in a set according to a supplied transformation. +
    +

    Usage

    +
    + BOOST_PP_SET_TRANSFORM(op, data, set) +
    +

    Arguments

    +
    +
    op
    +
    + A ternary predicate of the form op(s, data, elem).  + This transformation is expanded by BOOST_PP_SET_TRANSFORM for each element in set with the next available BOOST_PP_SET_FOLD_LEFT fold step, + the auxiliary data, and the current element in set.  +
    +
    data
    +
    + Auxiliary data passed to pred. +
    +
    set
    +
    + The set to be transformed. +
    +
    +

    Remarks

    +
    + This macro expands op for each element in set.  + It builds a new set out of the results of each call.  + If, for example, set is (a)(b)(c), + this macro expands to... +
    + (op(d, data, a))(op(d, data, b))(op(d, data, c)) +
    +
    +
    + For maximum efficiency, use BOOST_PP_SET_TRANSFORM_S. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/transform.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/set/transform.hpp>
+
+#define SET (1)(3)(2)(5)
+
+#define OP(s, data, elem) BOOST_PP_DEC(elem)
+
+BOOST_PP_SET_TRANSFORM(OP, 3, SET)
+   // expands to (0)(2)(1)(4)
+
    + + diff --git a/doc/ref/set_transform_s.html b/doc/ref/set_transform_s.html new file mode 100644 index 0000000..b1383a2 --- /dev/null +++ b/doc/ref/set_transform_s.html @@ -0,0 +1,55 @@ + + + BOOST_PP_SET_TRANSFORM_S + + + +
    + The BOOST_PP_SET_TRANSFORM_S macro transforms each element in a set according to a supplied transformation.  + It reenters BOOST_PP_SET_FOLD_LEFT with maximum efficiency. +
    +

    Usage

    +
    + BOOST_PP_SET_TRANSFORM_S(s, op, data, set) +
    +

    Arguments

    +
    +
    s
    +
    + The next available BOOST_PP_SET_FOLD_LEFT fold step. +
    +
    op
    +
    + A ternary predicate of the form op(s, data, elem).  + This transformation is expanded by BOOST_PP_SET_TRANSFORM for each element in set with the next available BOOST_PP_SET_FOLD_LEFT fold step, + the auxiliary data, and the current element in set.  +
    +
    data
    +
    + Auxiliary data passed to pred. +
    +
    set
    +
    + The set to be transformed. +
    +
    +

    Remarks

    +
    + This macro expands op for each element in set.  + It builds a new set out of the results of each call.  + If, for example, set is (a)(b)(c), + this macro expands to... +
    + (op(d, data, a))(op(d, data, b))(op(d, data, c)) +
    +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/set/transform.hpp> +
    + + diff --git a/doc/ref/tuple_rem_ctor.html b/doc/ref/tuple_rem_ctor.html new file mode 100644 index 0000000..5f00a5b --- /dev/null +++ b/doc/ref/tuple_rem_ctor.html @@ -0,0 +1,45 @@ + + + BOOST_PP_TUPLE_REM_CTOR + + + +
    + The BOOST_PP_TUPLE_REM_CTOR macro removes the parentheses from a tuple of the specified size. +
    +

    Usage

    +
    + BOOST_PP_TUPLE_REM_CTOR(size, tuple) +
    +

    Arguments

    +
    +
    size
    +
    + The size of the tuple from which the parentheses are to be removed.  + Valid tuple sizes range from 0 to BOOST_PP_LIMIT_TUPLE.  +
    +
    tuple
    +
    + The tuple from which the parenthesis are removed. +
    +
    +

    Remarks

    +
    + The size argument must be the actual size of tuple. +
    +

    See Also

    + +

    Requirements

    +
    + Header:  <boost/preprocessor/tuple/rem.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/tuple/rem.hpp>
+
+BOOST_PP_TUPLE_REM_CTOR(3, (x, y, z)) // expands to x, y, z
+
    + + diff --git a/doc/ref/tuple_to_set.html b/doc/ref/tuple_to_set.html new file mode 100644 index 0000000..c6da0dd --- /dev/null +++ b/doc/ref/tuple_to_set.html @@ -0,0 +1,36 @@ + + + BOOST_PP_TUPLE_TO_SET + + + +
    + The BOOST_PP_TUPLE_TO_SET macro converts a tuple to an set. +
    +

    Usage

    +
    + BOOST_PP_TUPLE_TO_SET(size, tuple) +
    +

    Arguments

    +
    +
    size
    +
    + The number of elements in tuple. +
    +
    tuple
    +
    + The tuple to be converted. +
    +
    +

    Requirements

    +
    + Header:  <boost/preprocessor/tuple/to_set.hpp> +
    +

    Sample Code

    +
    +#include <boost/preprocessor/tuple/to_set.hpp>
+
+BOOST_PP_TUPLE_TO_SET(3, (a, b, c)) // expands to (a)(b)(c)
+
    + + diff --git a/doc/syntax.html b/doc/syntax.html index bb0ba15..ed1f3ef 100644 --- a/doc/syntax.html +++ b/doc/syntax.html @@ -6,210 +6,232 @@

    Identifiers for Syntax Highlighting

    -BOOST_PP_ADD
    -BOOST_PP_ADD_D
    -BOOST_PP_AND
    -BOOST_PP_APPLY
    -BOOST_PP_ARRAY_DATA
    -BOOST_PP_ARRAY_ELEM
    -BOOST_PP_ARRAY_SIZE
    -BOOST_PP_ASSERT
    -BOOST_PP_ASSERT_MSG
    -BOOST_PP_ASSIGN_SLOT
    - -BOOST_PP_BITAND
    -BOOST_PP_BITNOR
    -BOOST_PP_BITOR
    -BOOST_PP_BITXOR
    -BOOST_PP_BOOL
    - -BOOST_PP_CAT
    -BOOST_PP_COMMA
    -BOOST_PP_COMMA_IF
    -BOOST_PP_COMPL
    -BOOST_PP_CONFIG_EXTENDED_LINE_INFO
    - -BOOST_PP_DEC
    -BOOST_PP_DEDUCE_D
    -BOOST_PP_DEDUCE_R
    -BOOST_PP_DEDUCE_Z
    -BOOST_PP_DIV
    -BOOST_PP_DIV_D
    - -BOOST_PP_EMPTY
    -BOOST_PP_ENUM
    -BOOST_PP_ENUM_BINARY_PARAMS
    -BOOST_PP_ENUM_BINARY_PARAMS_Z
    -BOOST_PP_ENUM_PARAMS
    -BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT
    -BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS
    -BOOST_PP_ENUM_PARAMS_Z
    -BOOST_PP_ENUM_SHIFTED
    -BOOST_PP_ENUM_SHIFTED_PARAMS
    -BOOST_PP_ENUM_SHIFTED_PARAMS_Z
    -BOOST_PP_ENUM_SHIFTED_
    -BOOST_PP_ENUM_TRAILING
    -BOOST_PP_ENUM_TRAILING_BINARY_PARAMS
    -BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z
    -BOOST_PP_ENUM_TRAILING_PARAMS
    -BOOST_PP_ENUM_TRAILING_PARAMS_Z
    -BOOST_PP_ENUM_TRAILING_
    -BOOST_PP_ENUM_
    -BOOST_PP_EQUAL
    -BOOST_PP_EQUAL_D
    -BOOST_PP_EXPAND
    -BOOST_PP_EXPR_IF
    -BOOST_PP_EXPR_IIF
    - -BOOST_PP_FILENAME_x
    -BOOST_PP_FOR
    -BOOST_PP_FOR_
    -BOOST_PP_FRAME_FINISH
    -BOOST_PP_FRAME_FLAGS
    -BOOST_PP_FRAME_ITERATION
    -BOOST_PP_FRAME_START
    - -BOOST_PP_GREATER
    -BOOST_PP_GREATER_D
    -BOOST_PP_GREATER_EQUAL
    -BOOST_PP_GREATER_EQUAL_D
    - -BOOST_PP_IDENTITY
    -BOOST_PP_IF
    -BOOST_PP_IIF
    -BOOST_PP_INC
    -BOOST_PP_INCLUDE_SELF
    -BOOST_PP_INDIRECT_SELF
    -BOOST_PP_INTERCEPT
    -BOOST_PP_IS_ITERATING
    -BOOST_PP_IS_SELFISH
    -BOOST_PP_ITERATE
    -BOOST_PP_ITERATION
    -BOOST_PP_ITERATION_DEPTH
    -BOOST_PP_ITERATION_FINISH
    -BOOST_PP_ITERATION_FLAGS
    -BOOST_PP_ITERATION_LIMITS
    -BOOST_PP_ITERATION_PARAMS_x
    -BOOST_PP_ITERATION_START
    - -BOOST_PP_LESS
    -BOOST_PP_LESS_D
    -BOOST_PP_LESS_EQUAL
    -BOOST_PP_LESS_EQUAL_D
    -BOOST_PP_LIMIT_DIM
    -BOOST_PP_LIMIT_FOR
    -BOOST_PP_LIMIT_ITERATION
    -BOOST_PP_LIMIT_ITERATION_DIM
    -BOOST_PP_LIMIT_MAG
    -BOOST_PP_LIMIT_REPEAT
    -BOOST_PP_LIMIT_SLOT_COUNT
    -BOOST_PP_LIMIT_SLOT_SIG
    -BOOST_PP_LIMIT_TUPLE
    -BOOST_PP_LIMIT_WHILE
    -BOOST_PP_LINE
    -BOOST_PP_LIST_APPEND
    -BOOST_PP_LIST_APPEND_D
    -BOOST_PP_LIST_AT
    -BOOST_PP_LIST_AT_D
    -BOOST_PP_LIST_CAT
    -BOOST_PP_LIST_CAT_D
    -BOOST_PP_LIST_CONS
    -BOOST_PP_LIST_ENUM
    -BOOST_PP_LIST_ENUM_R
    -BOOST_PP_LIST_FILTER
    -BOOST_PP_LIST_FILTER_D
    -BOOST_PP_LIST_FIRST
    -BOOST_PP_LIST_FIRST_N
    -BOOST_PP_LIST_FIRST_N_D
    -BOOST_PP_LIST_FOLD_LEFT
    -BOOST_PP_LIST_FOLD_LEFT_2ND
    -BOOST_PP_LIST_FOLD_LEFT_2ND_D
    -BOOST_PP_LIST_FOLD_LEFT_
    -BOOST_PP_LIST_FOLD_LEFT_D
    -BOOST_PP_LIST_FOLD_RIGHT
    -BOOST_PP_LIST_FOLD_RIGHT_2ND
    -BOOST_PP_LIST_FOLD_RIGHT_2ND_D
    -BOOST_PP_LIST_FOLD_RIGHT_
    -BOOST_PP_LIST_FOLD_RIGHT_D
    -BOOST_PP_LIST_FOR_EACH
    -BOOST_PP_LIST_FOR_EACH_I
    -BOOST_PP_LIST_FOR_EACH_I_R
    -BOOST_PP_LIST_FOR_EACH_PRODUCT
    -BOOST_PP_LIST_FOR_EACH_PRODUCT_R
    -BOOST_PP_LIST_FOR_EACH_R
    -BOOST_PP_LIST_IS_CONS
    -BOOST_PP_LIST_IS_NIL
    -BOOST_PP_LIST_NIL
    -BOOST_PP_LIST_REST
    -BOOST_PP_LIST_REST_N
    -BOOST_PP_LIST_REST_N_D
    -BOOST_PP_LIST_REVERSE
    -BOOST_PP_LIST_REVERSE_D
    -BOOST_PP_LIST_SIZE
    -BOOST_PP_LIST_SIZE_D
    -BOOST_PP_LIST_TO_TUPLE
    -BOOST_PP_LIST_TO_TUPLE_R
    -BOOST_PP_LIST_TRANSFORM
    -BOOST_PP_LIST_TRANSFORM_D
    -BOOST_PP_LOCAL_ITERATE
    -BOOST_PP_LOCAL_LIMITS
    -BOOST_PP_LOCAL_MACRO
    -BOOST_PP_LPAREN
    -BOOST_PP_LPAREN_IF
    - -BOOST_PP_MAX
    -BOOST_PP_MAX_D
    -BOOST_PP_MIN
    -BOOST_PP_MIN_D
    -BOOST_PP_MOD
    -BOOST_PP_MOD_D
    -BOOST_PP_MUL
    -BOOST_PP_MUL_D
    - -BOOST_PP_NIL
    -BOOST_PP_NOR
    -BOOST_PP_NOT
    -BOOST_PP_NOT_EQUAL
    -BOOST_PP_NOT_EQUAL_D
    - -BOOST_PP_OR
    - -BOOST_PP_RELATIVE_FINISH
    -BOOST_PP_RELATIVE_FLAGS
    -BOOST_PP_RELATIVE_ITERATION
    -BOOST_PP_RELATIVE_START
    -BOOST_PP_REPEAT
    -BOOST_PP_REPEAT_1ST
    -BOOST_PP_REPEAT_2ND
    -BOOST_PP_REPEAT_3RD
    -BOOST_PP_REPEAT_FROM_TO
    -BOOST_PP_REPEAT_FROM_TO_1ST
    -BOOST_PP_REPEAT_FROM_TO_2ND
    -BOOST_PP_REPEAT_FROM_TO_3RD
    -BOOST_PP_REPEAT_FROM_TO_D
    -BOOST_PP_REPEAT_FROM_TO_D_
    -BOOST_PP_REPEAT_FROM_TO_
    -BOOST_PP_REPEAT_
    -BOOST_PP_RPAREN
    -BOOST_PP_RPAREN_IF
    - -BOOST_PP_SLOT
    -BOOST_PP_STRINGIZE
    -BOOST_PP_SUB
    -BOOST_PP_SUB_D
    - -BOOST_PP_TUPLE_EAT
    -BOOST_PP_TUPLE_ELEM
    -BOOST_PP_TUPLE_REM
    -BOOST_PP_TUPLE_REVERSE
    -BOOST_PP_TUPLE_TO_LIST
    - -BOOST_PP_VALUE
    - -BOOST_PP_WHILE
    -BOOST_PP_WHILE_
    - -BOOST_PP_XOR
    +BOOST_PP_ADD +
    BOOST_PP_ADD_D +
    BOOST_PP_AND +
    BOOST_PP_APPLY +
    BOOST_PP_ARRAY_DATA +
    BOOST_PP_ARRAY_ELEM +
    BOOST_PP_ARRAY_SIZE +
    BOOST_PP_ASSERT +
    BOOST_PP_ASSERT_MSG +
    BOOST_PP_ASSIGN_SLOT +
    BOOST_PP_BITAND +
    BOOST_PP_BITNOR +
    BOOST_PP_BITOR +
    BOOST_PP_BITXOR +
    BOOST_PP_BOOL +
    BOOST_PP_CAT +
    BOOST_PP_COMMA +
    BOOST_PP_COMMA_IF +
    BOOST_PP_COMPL +
    BOOST_PP_CONFIG_EXTENDED_LINE_INFO +
    BOOST_PP_DEC +
    BOOST_PP_DEDUCE_D +
    BOOST_PP_DEDUCE_R +
    BOOST_PP_DEDUCE_Z +
    BOOST_PP_DIV +
    BOOST_PP_DIV_D +
    BOOST_PP_EMPTY +
    BOOST_PP_ENUM +
    BOOST_PP_ENUM_BINARY_PARAMS +
    BOOST_PP_ENUM_BINARY_PARAMS_Z +
    BOOST_PP_ENUM_PARAMS +
    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT +
    BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS +
    BOOST_PP_ENUM_PARAMS_Z +
    BOOST_PP_ENUM_SHIFTED +
    BOOST_PP_ENUM_SHIFTED_PARAMS +
    BOOST_PP_ENUM_SHIFTED_PARAMS_Z +
    BOOST_PP_ENUM_SHIFTED_ +
    BOOST_PP_ENUM_TRAILING +
    BOOST_PP_ENUM_TRAILING_BINARY_PARAMS +
    BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z +
    BOOST_PP_ENUM_TRAILING_PARAMS +
    BOOST_PP_ENUM_TRAILING_PARAMS_Z +
    BOOST_PP_ENUM_TRAILING_ +
    BOOST_PP_ENUM_ +
    BOOST_PP_EQUAL +
    BOOST_PP_EQUAL_D +
    BOOST_PP_EXPAND +
    BOOST_PP_EXPR_IF +
    BOOST_PP_EXPR_IIF +
    BOOST_PP_FILENAME_x +
    BOOST_PP_FOR +
    BOOST_PP_FOR_ +
    BOOST_PP_FRAME_FINISH +
    BOOST_PP_FRAME_FLAGS +
    BOOST_PP_FRAME_ITERATION +
    BOOST_PP_FRAME_START +
    BOOST_PP_GREATER +
    BOOST_PP_GREATER_D +
    BOOST_PP_GREATER_EQUAL +
    BOOST_PP_GREATER_EQUAL_D +
    BOOST_PP_IDENTITY +
    BOOST_PP_IF +
    BOOST_PP_IIF +
    BOOST_PP_INC +
    BOOST_PP_INCLUDE_SELF +
    BOOST_PP_INDIRECT_SELF +
    BOOST_PP_INTERCEPT +
    BOOST_PP_IS_ITERATING +
    BOOST_PP_IS_SELFISH +
    BOOST_PP_ITERATE +
    BOOST_PP_ITERATION +
    BOOST_PP_ITERATION_DEPTH +
    BOOST_PP_ITERATION_FINISH +
    BOOST_PP_ITERATION_FLAGS +
    BOOST_PP_ITERATION_LIMITS +
    BOOST_PP_ITERATION_PARAMS_x +
    BOOST_PP_ITERATION_START +
    BOOST_PP_LESS +
    BOOST_PP_LESS_D +
    BOOST_PP_LESS_EQUAL +
    BOOST_PP_LESS_EQUAL_D +
    BOOST_PP_LIMIT_DIM +
    BOOST_PP_LIMIT_FOR +
    BOOST_PP_LIMIT_ITERATION +
    BOOST_PP_LIMIT_ITERATION_DIM +
    BOOST_PP_LIMIT_MAG +
    BOOST_PP_LIMIT_REPEAT +
    BOOST_PP_LIMIT_SET +
    BOOST_PP_LIMIT_SLOT_COUNT +
    BOOST_PP_LIMIT_SLOT_SIG +
    BOOST_PP_LIMIT_TUPLE +
    BOOST_PP_LIMIT_WHILE +
    BOOST_PP_LINE +
    BOOST_PP_LIST_APPEND +
    BOOST_PP_LIST_APPEND_D +
    BOOST_PP_LIST_AT +
    BOOST_PP_LIST_AT_D +
    BOOST_PP_LIST_CAT +
    BOOST_PP_LIST_CAT_D +
    BOOST_PP_LIST_CONS +
    BOOST_PP_LIST_ENUM +
    BOOST_PP_LIST_ENUM_R +
    BOOST_PP_LIST_FILTER +
    BOOST_PP_LIST_FILTER_D +
    BOOST_PP_LIST_FIRST +
    BOOST_PP_LIST_FIRST_N +
    BOOST_PP_LIST_FIRST_N_D +
    BOOST_PP_LIST_FOLD_LEFT +
    BOOST_PP_LIST_FOLD_LEFT_2ND +
    BOOST_PP_LIST_FOLD_LEFT_2ND_D +
    BOOST_PP_LIST_FOLD_LEFT_ +
    BOOST_PP_LIST_FOLD_LEFT_D +
    BOOST_PP_LIST_FOLD_RIGHT +
    BOOST_PP_LIST_FOLD_RIGHT_2ND +
    BOOST_PP_LIST_FOLD_RIGHT_2ND_D +
    BOOST_PP_LIST_FOLD_RIGHT_ +
    BOOST_PP_LIST_FOLD_RIGHT_D +
    BOOST_PP_LIST_FOR_EACH +
    BOOST_PP_LIST_FOR_EACH_I +
    BOOST_PP_LIST_FOR_EACH_I_R +
    BOOST_PP_LIST_FOR_EACH_PRODUCT +
    BOOST_PP_LIST_FOR_EACH_PRODUCT_R +
    BOOST_PP_LIST_FOR_EACH_R +
    BOOST_PP_LIST_IS_CONS +
    BOOST_PP_LIST_IS_NIL +
    BOOST_PP_LIST_NIL +
    BOOST_PP_LIST_REST +
    BOOST_PP_LIST_REST_N +
    BOOST_PP_LIST_REST_N_D +
    BOOST_PP_LIST_REVERSE +
    BOOST_PP_LIST_REVERSE_D +
    BOOST_PP_LIST_SIZE +
    BOOST_PP_LIST_SIZE_D +
    BOOST_PP_LIST_TO_TUPLE +
    BOOST_PP_LIST_TO_TUPLE_R +
    BOOST_PP_LIST_TRANSFORM +
    BOOST_PP_LIST_TRANSFORM_D +
    BOOST_PP_LOCAL_ITERATE +
    BOOST_PP_LOCAL_LIMITS +
    BOOST_PP_LOCAL_MACRO +
    BOOST_PP_LPAREN +
    BOOST_PP_LPAREN_IF +
    BOOST_PP_MAX +
    BOOST_PP_MAX_D +
    BOOST_PP_MIN +
    BOOST_PP_MIN_D +
    BOOST_PP_MOD +
    BOOST_PP_MOD_D +
    BOOST_PP_MUL +
    BOOST_PP_MUL_D +
    BOOST_PP_NIL +
    BOOST_PP_NOR +
    BOOST_PP_NOT +
    BOOST_PP_NOT_EQUAL +
    BOOST_PP_NOT_EQUAL_D +
    BOOST_PP_OR +
    BOOST_PP_RELATIVE_FINISH +
    BOOST_PP_RELATIVE_FLAGS +
    BOOST_PP_RELATIVE_ITERATION +
    BOOST_PP_RELATIVE_START +
    BOOST_PP_REPEAT +
    BOOST_PP_REPEAT_1ST +
    BOOST_PP_REPEAT_2ND +
    BOOST_PP_REPEAT_3RD +
    BOOST_PP_REPEAT_FROM_TO +
    BOOST_PP_REPEAT_FROM_TO_1ST +
    BOOST_PP_REPEAT_FROM_TO_2ND +
    BOOST_PP_REPEAT_FROM_TO_3RD +
    BOOST_PP_REPEAT_FROM_TO_D +
    BOOST_PP_REPEAT_FROM_TO_D_ +
    BOOST_PP_REPEAT_FROM_TO_ +
    BOOST_PP_REPEAT_ +
    BOOST_PP_RPAREN +
    BOOST_PP_RPAREN_IF +
    BOOST_PP_SET_CAT +
    BOOST_PP_SET_CAT_S +
    BOOST_PP_SET_ELEM +
    BOOST_PP_SET_ENUM +
    BOOST_PP_SET_FILTER +
    BOOST_PP_SET_FILTER_S +
    BOOST_PP_SET_FIRST_N +
    BOOST_PP_SET_FOLD_LEFT +
    BOOST_PP_SET_FOLD_LEFT_ +
    BOOST_PP_SET_FOLD_RIGHT +
    BOOST_PP_SET_FOLD_RIGHT_ +
    BOOST_PP_SET_FOR_EACH +
    BOOST_PP_SET_FOR_EACH_R +
    BOOST_PP_SET_FOR_EACH_I +
    BOOST_PP_SET_FOR_EACH_I_R +
    BOOST_PP_SET_FOR_EACH_PRODUCT +
    BOOST_PP_SET_FOR_EACH_PRODUCT_R +
    BOOST_PP_SET_HEAD +
    BOOST_PP_SET_INSERT +
    BOOST_PP_SET_NIL +
    BOOST_PP_SET_POP_BACK +
    BOOST_PP_SET_POP_FRONT +
    BOOST_PP_SET_PUSH_BACK +
    BOOST_PP_SET_PUSH_FRONT +
    BOOST_PP_SET_REMOVE +
    BOOST_PP_SET_REPLACE +
    BOOST_PP_SET_REST_N +
    BOOST_PP_SET_REVERSE +
    BOOST_PP_SET_REVERSE_S +
    BOOST_PP_SET_SIZE +
    BOOST_PP_SET_SUBSET +
    BOOST_PP_SET_TAIL +
    BOOST_PP_SET_TO_ARRAY +
    BOOST_PP_SET_TO_TUPLE +
    BOOST_PP_SET_TRANSFORM +
    BOOST_PP_SET_TRANSFORM_S +
    BOOST_PP_SLOT +
    BOOST_PP_STRINGIZE +
    BOOST_PP_SUB +
    BOOST_PP_SUB_D +
    BOOST_PP_TUPLE_EAT +
    BOOST_PP_TUPLE_ELEM +
    BOOST_PP_TUPLE_REM +
    BOOST_PP_TUPLE_REM_CTOR +
    BOOST_PP_TUPLE_REVERSE +
    BOOST_PP_TUPLE_TO_LIST +
    BOOST_PP_TUPLE_TO_SET +
    BOOST_PP_VALUE +
    BOOST_PP_WHILE +
    BOOST_PP_WHILE_ +
    BOOST_PP_XOR