1 # /* ************************************************************************** 2 # * * 3 # * (C) Copyright Paul Mensonides 2002. 4 # * Distributed under the Boost Software License, Version 1.0. (See 5 # * accompanying file LICENSE_1_0.txt or copy at 6 # * http://www.boost.org/LICENSE_1_0.txt) 7 # * * 8 # ************************************************************************** */ 9 # 10 # /* Revised by Edward Diener (2011,2013) */ 11 # 12 # /* See http://www.boost.org for most recent version. */ 13 # 14 # include <boost/preprocessor/config/limits.hpp> 15 # include <boost/preprocessor/array.hpp> 16 # include <libs/preprocessor/test/test.h> 17 # include <boost/preprocessor/facilities/is_empty.hpp> 18 # include <boost/preprocessor/list/at.hpp> 19 # include <boost/preprocessor/list/size.hpp> 20 # include <boost/preprocessor/seq/elem.hpp> 21 # include <boost/preprocessor/seq/size.hpp> 22 # include <boost/preprocessor/tuple/elem.hpp> 23 # include <boost/preprocessor/tuple/size.hpp> 24 # include <boost/preprocessor/variadic/size.hpp> 25 # include <boost/preprocessor/variadic/elem.hpp> 26 # include <boost/preprocessor/variadic/has_opt.hpp> 27 28 # define ARRAY_EMPTY (0, ()) 29 # define ARRAY_ONE (1, ()) 30 # define ARRAY (3, (0, 1, 2)) 31 # define ARRAY_LARGE (33, (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)) 32 # define ARRAY_VERY_LARGE (64, (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)) 33 34 #if BOOST_PP_LIMIT_TUPLE > 64 35 36 # define ARRAY_LARGE_128 \ 37 ( 104, \ 38 ( 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, \ 39 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 ) \ 40 ) 41 42 # define ARRAY_VERY_LARGE_128 \ 43 ( 128, \ 44 ( 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, \ 45 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 ) \ 46 ) 47 48 #endif 49 50 #if BOOST_PP_LIMIT_TUPLE > 128 51 52 # define ARRAY_LARGE_256 \ 53 ( 142, \ 54 ( 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, \ 55 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, \ 56 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141 ) \ 57 ) 58 59 # define ARRAY_VERY_LARGE_256 \ 60 ( 256, \ 61 ( 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, \ 62 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, \ 63 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, \ 64 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 ) \ 65 ) 66 67 # define ARRAY_VERY_LARGE_255 \ 68 ( 255, \ 69 ( 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, \ 70 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, \ 71 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, \ 72 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 ) \ 73 ) 74 75 #endif 76 77 // element access 78 79 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, ARRAY_ONE)) == 1 END 80 BEGIN BOOST_PP_ARRAY_ELEM(1, ARRAY) == 1 END 81 BEGIN BOOST_PP_ARRAY_ELEM(2, (5, (0, 1, 2, 3, 4))) == 2 END 82 BEGIN BOOST_PP_ARRAY_ELEM(28, ARRAY_LARGE) == 28 END 83 BEGIN BOOST_PP_ARRAY_ELEM(17, (33, (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))) == 17 END 84 BEGIN BOOST_PP_ARRAY_ELEM(42, ARRAY_VERY_LARGE) == 42 END 85 BEGIN BOOST_PP_ARRAY_ELEM(62, (64, (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))) == 62 END 86 87 // size 88 89 BEGIN BOOST_PP_ARRAY_SIZE(ARRAY) == 3 END 90 BEGIN BOOST_PP_ARRAY_SIZE((5, (0, 1, 2, 3, 4))) == 5 END 91 BEGIN BOOST_PP_ARRAY_SIZE(ARRAY_LARGE) == 33 END 92 BEGIN BOOST_PP_ARRAY_SIZE((33, (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 END 93 BEGIN BOOST_PP_ARRAY_SIZE(ARRAY_VERY_LARGE) == 64 END 94 BEGIN BOOST_PP_ARRAY_SIZE((64, (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 END 95 BEGIN BOOST_PP_ARRAY_SIZE(ARRAY_EMPTY) == 0 END 96 BEGIN BOOST_PP_ARRAY_SIZE(ARRAY_ONE) == 1 END 97 98 #if BOOST_PP_LIMIT_TUPLE > 64 99 100 BEGIN BOOST_PP_ARRAY_ELEM(73, ARRAY_LARGE_128) == 73 END 101 BEGIN BOOST_PP_ARRAY_ELEM(89, ARRAY_LARGE_128) == 89 END 102 BEGIN BOOST_PP_ARRAY_ELEM(101, ARRAY_LARGE_128) == 101 END 103 BEGIN BOOST_PP_ARRAY_ELEM(95, ARRAY_VERY_LARGE_128) == 95 END 104 BEGIN BOOST_PP_ARRAY_ELEM(110, ARRAY_VERY_LARGE_128) == 110 END 105 BEGIN BOOST_PP_ARRAY_ELEM(126, ARRAY_VERY_LARGE_128) == 126 END 106 107 #endif 108 109 #if BOOST_PP_LIMIT_TUPLE > 128 110 111 BEGIN BOOST_PP_ARRAY_ELEM(83, ARRAY_LARGE_256) == 83 END 112 BEGIN BOOST_PP_ARRAY_ELEM(131, ARRAY_LARGE_256) == 131 END 113 BEGIN BOOST_PP_ARRAY_ELEM(140, ARRAY_LARGE_256) == 140 END 114 BEGIN BOOST_PP_ARRAY_ELEM(174, ARRAY_VERY_LARGE_256) == 174 END 115 BEGIN BOOST_PP_ARRAY_ELEM(226, ARRAY_VERY_LARGE_256) == 226 END 116 BEGIN BOOST_PP_ARRAY_ELEM(253, ARRAY_VERY_LARGE_256) == 253 END 117 118 #endif 119 120 // enum 121 122 BEGIN BOOST_PP_VARIADIC_ELEM(2,BOOST_PP_ARRAY_ENUM(ARRAY)) == 2 END 123 BEGIN BOOST_PP_VARIADIC_ELEM(3,BOOST_PP_ARRAY_ENUM((5, (0, 1, 2, 3, 4)))) == 3 END 124 BEGIN BOOST_PP_VARIADIC_ELEM(31,BOOST_PP_ARRAY_ENUM(ARRAY_LARGE)) == 31 END 125 BEGIN BOOST_PP_VARIADIC_ELEM(13,BOOST_PP_ARRAY_ENUM((33, (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)))) == 13 END 126 BEGIN BOOST_PP_VARIADIC_ELEM(39,BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE)) == 39 END 127 BEGIN BOOST_PP_VARIADIC_ELEM(24,BOOST_PP_ARRAY_ENUM((64, (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)))) == 24 END 128 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM((5, (0, 1, 2, 3, 4)))) == 5 END 129 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE)) == 33 END 130 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE)) == 64 END 131 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM((64, (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 END 132 133 # if BOOST_PP_VARIADIC_HAS_OPT() 134 135 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_ONE)) == 0 END 136 137 # else 138 139 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_ONE)) == 1 END 140 141 #endif 142 143 #if BOOST_PP_LIMIT_TUPLE > 64 144 145 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE_128)) == 104 END 146 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE_128)) == 128 END 147 148 #endif 149 150 #if BOOST_PP_LIMIT_TUPLE > 128 151 152 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_LARGE_256)) == 142 END 153 BEGIN BOOST_PP_VARIADIC_SIZE(BOOST_PP_ARRAY_ENUM(ARRAY_VERY_LARGE_256)) == 256 END 154 155 #endif 156 157 // to_list 158 159 BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY), 1) == 1 END 160 BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST((5, (0, 1, 2, 3, 4))), 4) == 4 END 161 BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST((33, (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))), 26) == 26 END 162 BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE), 60) == 60 END 163 BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_ARRAY_TO_LIST(ARRAY_EMPTY)) == 0 END 164 BEGIN BOOST_PP_LIST_SIZE(BOOST_PP_ARRAY_TO_LIST(ARRAY_ONE)) == 1 END 165 166 #if BOOST_PP_LIMIT_TUPLE > 64 167 168 BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_LARGE_128), 88) == 88 END 169 BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE_128), 113) == 113 END 170 171 #endif 172 173 #if BOOST_PP_LIMIT_TUPLE > 128 174 175 BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_LARGE_256), 137) == 137 END 176 BEGIN BOOST_PP_LIST_AT(BOOST_PP_ARRAY_TO_LIST(ARRAY_VERY_LARGE_256), 235) == 235 END 177 178 #endif 179 180 // to_seq 181 182 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_SEQ_ELEM(0, BOOST_PP_ARRAY_TO_SEQ(ARRAY_ONE))) == 1 END 183 BEGIN BOOST_PP_SEQ_ELEM(0, BOOST_PP_ARRAY_TO_SEQ(ARRAY)) == 0 END 184 BEGIN BOOST_PP_SEQ_ELEM(3, BOOST_PP_ARRAY_TO_SEQ((5, (0, 1, 2, 3, 4)))) == 3 END 185 BEGIN BOOST_PP_SEQ_ELEM(17, BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE)) == 17 END 186 BEGIN BOOST_PP_SEQ_ELEM(42, BOOST_PP_ARRAY_TO_SEQ((64, (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)))) == 42 END 187 188 #if BOOST_PP_LIMIT_TUPLE > 64 189 190 BEGIN BOOST_PP_SEQ_ELEM(97,BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE_128)) == 97 END 191 BEGIN BOOST_PP_SEQ_ELEM(123,BOOST_PP_ARRAY_TO_SEQ(ARRAY_VERY_LARGE_128)) == 123 END 192 193 #endif 194 195 #if BOOST_PP_LIMIT_TUPLE > 128 196 197 BEGIN BOOST_PP_SEQ_ELEM(53,BOOST_PP_ARRAY_TO_SEQ(ARRAY_LARGE_256)) == 53 END 198 BEGIN BOOST_PP_SEQ_ELEM(181,BOOST_PP_ARRAY_TO_SEQ(ARRAY_VERY_LARGE_256)) == 181 END 199 200 #endif 201 202 // to_tuple 203 204 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_TUPLE_ELEM(0, BOOST_PP_ARRAY_TO_TUPLE(ARRAY_ONE))) == 1 END 205 BEGIN BOOST_PP_TUPLE_ELEM(2, BOOST_PP_ARRAY_TO_TUPLE(ARRAY)) == 2 END 206 BEGIN BOOST_PP_TUPLE_ELEM(1, BOOST_PP_ARRAY_TO_TUPLE((5, (0, 1, 2, 3, 4)))) == 1 END 207 BEGIN BOOST_PP_TUPLE_ELEM(26, BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE)) == 26 END 208 BEGIN BOOST_PP_TUPLE_ELEM(37, BOOST_PP_ARRAY_TO_TUPLE((64, (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)))) == 37 END 209 210 #if BOOST_PP_LIMIT_TUPLE > 64 211 212 BEGIN BOOST_PP_TUPLE_ELEM(97,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE_128)) == 97 END 213 BEGIN BOOST_PP_TUPLE_ELEM(123,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_VERY_LARGE_128)) == 123 END 214 215 #endif 216 217 #if BOOST_PP_LIMIT_TUPLE > 128 218 219 BEGIN BOOST_PP_TUPLE_ELEM(53,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_LARGE_256)) == 53 END 220 BEGIN BOOST_PP_TUPLE_ELEM(181,BOOST_PP_ARRAY_TO_TUPLE(ARRAY_VERY_LARGE_256)) == 181 END 221 222 #endif 223 224 // insert 225 226 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY_ONE,0,63)) == 63 END 227 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY,2,40)) == 0 END 228 BEGIN BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 40 END 229 BEGIN BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 1 END 230 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY,1,40)) == 4 END 231 232 BEGIN BOOST_PP_ARRAY_ELEM(8, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 8 END 233 BEGIN BOOST_PP_ARRAY_ELEM(22, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 1000 END 234 BEGIN BOOST_PP_ARRAY_ELEM(26, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 25 END 235 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE,22,1000)) == 34 END 236 237 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_INSERT(ARRAY_EMPTY,0,25)) == 25 END 238 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_EMPTY,0,1000)) == 1 END 239 240 #if BOOST_PP_LIMIT_TUPLE > 64 241 242 BEGIN BOOST_PP_ARRAY_ELEM(69, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,76,1000)) == 69 END 243 BEGIN BOOST_PP_ARRAY_ELEM(101, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,101,1000)) == 1000 END 244 BEGIN BOOST_PP_ARRAY_ELEM(98, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,96,1000)) == 97 END 245 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_128,84,1000)) == 105 END 246 247 #endif 248 249 #if BOOST_PP_LIMIT_TUPLE > 128 250 251 BEGIN BOOST_PP_ARRAY_ELEM(73, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,134,1000)) == 73 END 252 BEGIN BOOST_PP_ARRAY_ELEM(141, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,141,1000)) == 1000 END 253 BEGIN BOOST_PP_ARRAY_ELEM(133, BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,39,1000)) == 132 END 254 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_INSERT(ARRAY_LARGE_256,121,1000)) == 143 END 255 BEGIN BOOST_PP_ARRAY_ELEM(227,BOOST_PP_ARRAY_INSERT(ARRAY_VERY_LARGE_255,212,1000)) == 226 END 256 BEGIN BOOST_PP_ARRAY_ELEM(212,BOOST_PP_ARRAY_INSERT(ARRAY_VERY_LARGE_255,212,1000)) == 1000 END 257 258 #endif 259 260 // pop_back 261 262 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY)) == 2 END 263 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE)) == 32 END 264 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE)) == 63 END 265 266 #if BOOST_PP_LIMIT_TUPLE > 64 267 268 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE_128)) == 103 END 269 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE_128)) == 127 END 270 271 #endif 272 273 #if BOOST_PP_LIMIT_TUPLE > 128 274 275 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_LARGE_256)) == 141 END 276 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_BACK(ARRAY_VERY_LARGE_256)) == 255 END 277 278 #endif 279 280 // pop_front 281 282 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY)) == 2 END 283 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE)) == 32 END 284 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE)) == 63 END 285 286 BEGIN BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_POP_FRONT(ARRAY)) == 2 END 287 BEGIN BOOST_PP_ARRAY_ELEM(31, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE)) == 32 END 288 BEGIN BOOST_PP_ARRAY_ELEM(55, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE)) == 56 END 289 290 #if BOOST_PP_LIMIT_TUPLE > 64 291 292 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_128)) == 103 END 293 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_128)) == 127 END 294 BEGIN BOOST_PP_ARRAY_ELEM(84, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_128)) == 85 END 295 BEGIN BOOST_PP_ARRAY_ELEM(117, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_128)) == 118 END 296 297 #endif 298 299 #if BOOST_PP_LIMIT_TUPLE > 128 300 301 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_256)) == 141 END 302 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_256)) == 255 END 303 BEGIN BOOST_PP_ARRAY_ELEM(129, BOOST_PP_ARRAY_POP_FRONT(ARRAY_LARGE_256)) == 130 END 304 BEGIN BOOST_PP_ARRAY_ELEM(248, BOOST_PP_ARRAY_POP_FRONT(ARRAY_VERY_LARGE_256)) == 249 END 305 306 #endif 307 308 // push_back 309 310 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY, 3)) == 4 END 311 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE, 33)) == 34 END 312 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_EMPTY, 10)) == 1 END 313 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_ONE, 44)) == 2 END 314 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_BACK(ARRAY, 3)) == 0 END 315 BEGIN BOOST_PP_ARRAY_ELEM(33, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE, 33)) == 33 END 316 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_EMPTY, 136)) == 136 END 317 BEGIN BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_ONE, 245)) == 245 END 318 319 #if BOOST_PP_LIMIT_TUPLE > 64 320 321 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_128, 66)) == 105 END 322 BEGIN BOOST_PP_ARRAY_ELEM(104, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_128, 101)) == 101 END 323 324 #endif 325 326 #if BOOST_PP_LIMIT_TUPLE > 128 327 328 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_256, 192)) == 143 END 329 BEGIN BOOST_PP_ARRAY_ELEM(142, BOOST_PP_ARRAY_PUSH_BACK(ARRAY_LARGE_256, 77)) == 77 END 330 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_BACK(ARRAY_VERY_LARGE_255, 255)) == 256 END 331 332 #endif 333 334 // push_front 335 336 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY, 555)) == 4 END 337 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE, 666)) == 34 END 338 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_EMPTY, 10)) == 1 END 339 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_ONE, 131)) == 2 END 340 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY, 555)) == 555 END 341 BEGIN BOOST_PP_ARRAY_ELEM(33, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE, 33)) == 32 END 342 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_EMPTY, 136)) == 136 END 343 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_ONE, 56)) == 56 END 344 345 #if BOOST_PP_LIMIT_TUPLE > 64 346 347 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_128, 666)) == 105 END 348 BEGIN BOOST_PP_ARRAY_ELEM(103, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_128, 29)) == 102 END 349 350 #endif 351 352 #if BOOST_PP_LIMIT_TUPLE > 128 353 354 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_256, 333)) == 143 END 355 BEGIN BOOST_PP_ARRAY_ELEM(136, BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_LARGE_256, 47)) == 135 END 356 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_PUSH_FRONT(ARRAY_VERY_LARGE_255, 4)) == 256 END 357 358 #endif 359 360 // remove 361 362 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_ONE, 0)) == 0 END 363 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY, 1)) == 2 END 364 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE, 17)) == 32 END 365 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE, 27)) == 63 END 366 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REMOVE(ARRAY, 2)) == 0 END 367 BEGIN BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE, 25)) == 30 END 368 BEGIN BOOST_PP_ARRAY_ELEM(62, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE, 48)) == 63 END 369 370 #if BOOST_PP_LIMIT_TUPLE > 64 371 372 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 100)) == 103 END 373 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 123)) == 127 END 374 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 0)) == 127 END 375 BEGIN BOOST_PP_ARRAY_ELEM(102, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 97)) == 103 END 376 BEGIN BOOST_PP_ARRAY_ELEM(76, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_128, 0)) == 77 END 377 BEGIN BOOST_PP_ARRAY_ELEM(119, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_128, 115)) == 120 END 378 379 #endif 380 381 #if BOOST_PP_LIMIT_TUPLE > 128 382 383 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 133)) == 141 END 384 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 0)) == 141 END 385 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 241)) == 255 END 386 BEGIN BOOST_PP_ARRAY_ELEM(140, BOOST_PP_ARRAY_REMOVE(ARRAY_LARGE_256, 138)) == 141 END 387 BEGIN BOOST_PP_ARRAY_ELEM(181, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 166)) == 182 END 388 BEGIN BOOST_PP_ARRAY_ELEM(236, BOOST_PP_ARRAY_REMOVE(ARRAY_VERY_LARGE_256, 0)) == 237 END 389 390 #endif 391 392 // replace 393 394 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_ONE, 0, 3)) == 1 END 395 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 27, 1000)) == 64 END 396 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_ONE, 0, 68)) == 68 END 397 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY, 1, 44)) == 0 END 398 BEGIN BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE, 29, 999)) == 999 END 399 BEGIN BOOST_PP_ARRAY_ELEM(38, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 37, 1)) == 38 END 400 BEGIN BOOST_PP_ARRAY_ELEM(28, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE, 28, 1)) == 1 END 401 402 #if BOOST_PP_LIMIT_TUPLE > 64 403 404 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 93, 1000)) == 128 END 405 BEGIN BOOST_PP_ARRAY_ELEM(89, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE_128, 89, 111)) == 111 END 406 BEGIN BOOST_PP_ARRAY_ELEM(73, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 66, 1)) == 73 END 407 BEGIN BOOST_PP_ARRAY_ELEM(122, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 122, 1)) == 1 END 408 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 0, 128)) == 128 END 409 BEGIN BOOST_PP_ARRAY_ELEM(95, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_128, 0, 128)) == 95 END 410 411 #endif 412 413 #if BOOST_PP_LIMIT_TUPLE > 128 414 415 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 217, 1000)) == 256 END 416 BEGIN BOOST_PP_ARRAY_ELEM(136, BOOST_PP_ARRAY_REPLACE(ARRAY_LARGE_256, 136, 999)) == 999 END 417 BEGIN BOOST_PP_ARRAY_ELEM(192, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 185, 1)) == 192 END 418 BEGIN BOOST_PP_ARRAY_ELEM(237, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 237, 1)) == 1 END 419 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 0, 256)) == 256 END 420 BEGIN BOOST_PP_ARRAY_ELEM(167, BOOST_PP_ARRAY_REPLACE(ARRAY_VERY_LARGE_256, 0, 256)) == 167 END 421 422 #endif 423 424 // reverse 425 426 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE)) == 64 END 427 428 #if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() 429 430 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY_ONE))) == 1 END 431 432 #else 433 434 // BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY_ONE))) == 1 END 435 BEGIN BOOST_PP_IS_EMPTY(BOOST_PP_ARRAY_ELEM(0, ARRAY_ONE)) == 1 END 436 437 #endif 438 439 BEGIN BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ARRAY_REVERSE(ARRAY)) == 2 END 440 BEGIN BOOST_PP_ARRAY_ELEM(29, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE)) == 3 END 441 BEGIN BOOST_PP_ARRAY_ELEM(38, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE)) == 25 END 442 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_EMPTY)) == 0 END 443 BEGIN BOOST_PP_ARRAY_SIZE(BOOST_PP_ARRAY_REVERSE(ARRAY_ONE)) == 1 END 444 445 #if BOOST_PP_LIMIT_TUPLE > 64 446 447 BEGIN BOOST_PP_ARRAY_ELEM(83, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE_128)) == 20 END 448 BEGIN BOOST_PP_ARRAY_ELEM(119, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE_128)) == 8 END 449 450 #endif 451 452 #if BOOST_PP_LIMIT_TUPLE > 128 453 454 BEGIN BOOST_PP_ARRAY_ELEM(56, BOOST_PP_ARRAY_REVERSE(ARRAY_LARGE_256)) == 85 END 455 BEGIN BOOST_PP_ARRAY_ELEM(212, BOOST_PP_ARRAY_REVERSE(ARRAY_VERY_LARGE_256)) == 43 END 456 457 #endif 458