rroonga 6.0.5-x86-mingw32 → 6.0.7-x86-mingw32

data/vendor/local/include/msgpack/preprocessor/seq/for_each.hpp

@@ -14,47 +14,94 @@
 #
 # include <msgpack/preprocessor/arithmetic/dec.hpp>
 # include <msgpack/preprocessor/config/config.hpp>
+# include <msgpack/preprocessor/control/if.hpp>
+# include <msgpack/preprocessor/control/iif.hpp>
 # include <msgpack/preprocessor/repetition/for.hpp>
 # include <msgpack/preprocessor/seq/seq.hpp>
 # include <msgpack/preprocessor/seq/size.hpp>
+# include <msgpack/preprocessor/seq/detail/is_empty.hpp>
 # include <msgpack/preprocessor/tuple/elem.hpp>
 # include <msgpack/preprocessor/tuple/rem.hpp>
 #
 # /* MSGPACK_PP_SEQ_FOR_EACH */
 #
 # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG()
-#    define MSGPACK_PP_SEQ_FOR_EACH(macro, data, seq) MSGPACK_PP_FOR((macro, data, seq (nil)), MSGPACK_PP_SEQ_FOR_EACH_P, MSGPACK_PP_SEQ_FOR_EACH_O, MSGPACK_PP_SEQ_FOR_EACH_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH(macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK(macro, data, seq)
 # else
 #    define MSGPACK_PP_SEQ_FOR_EACH(macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_D(macro, data, seq)
-#    define MSGPACK_PP_SEQ_FOR_EACH_D(macro, data, seq) MSGPACK_PP_FOR((macro, data, seq (nil)), MSGPACK_PP_SEQ_FOR_EACH_P, MSGPACK_PP_SEQ_FOR_EACH_O, MSGPACK_PP_SEQ_FOR_EACH_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_D(macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK(macro, data, seq)
 # endif
 #
-# define MSGPACK_PP_SEQ_FOR_EACH_P(r, x) MSGPACK_PP_DEC(MSGPACK_PP_SEQ_SIZE(MSGPACK_PP_TUPLE_ELEM(3, 2, x)))
+#    define MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC(macro, data, seq) MSGPACK_PP_FOR((macro, data, seq, MSGPACK_PP_SEQ_SIZE(seq)), MSGPACK_PP_SEQ_FOR_EACH_P, MSGPACK_PP_SEQ_FOR_EACH_O, MSGPACK_PP_SEQ_FOR_EACH_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY(macro, data, seq)
+#
+#    define MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK(macro, data, seq) \
+		MSGPACK_PP_IIF \
+			( \
+			MSGPACK_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
+			MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC, \
+			MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY \
+			) \
+		(macro, data, seq) \
+/**/
+#
+# define MSGPACK_PP_SEQ_FOR_EACH_P(r, x) MSGPACK_PP_TUPLE_ELEM(4, 3, x)
 #
 # if MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_STRICT()
 #    define MSGPACK_PP_SEQ_FOR_EACH_O(r, x) MSGPACK_PP_SEQ_FOR_EACH_O_I x
 # else
-#    define MSGPACK_PP_SEQ_FOR_EACH_O(r, x) MSGPACK_PP_SEQ_FOR_EACH_O_I(MSGPACK_PP_TUPLE_ELEM(3, 0, x), MSGPACK_PP_TUPLE_ELEM(3, 1, x), MSGPACK_PP_TUPLE_ELEM(3, 2, x))
+#    define MSGPACK_PP_SEQ_FOR_EACH_O(r, x) MSGPACK_PP_SEQ_FOR_EACH_O_I(MSGPACK_PP_TUPLE_ELEM(4, 0, x), MSGPACK_PP_TUPLE_ELEM(4, 1, x), MSGPACK_PP_TUPLE_ELEM(4, 2, x), MSGPACK_PP_TUPLE_ELEM(4, 3, x))
 # endif
 #
-# define MSGPACK_PP_SEQ_FOR_EACH_O_I(macro, data, seq) (macro, data, MSGPACK_PP_SEQ_TAIL(seq))
+# define MSGPACK_PP_SEQ_FOR_EACH_O_I(macro, data, seq, sz) \
+	MSGPACK_PP_SEQ_FOR_EACH_O_I_DEC(macro, data, seq, MSGPACK_PP_DEC(sz)) \
+/**/
+# define MSGPACK_PP_SEQ_FOR_EACH_O_I_DEC(macro, data, seq, sz) \
+	( \
+	macro, \
+	data, \
+	MSGPACK_PP_IF \
+		( \
+		sz, \
+		MSGPACK_PP_SEQ_FOR_EACH_O_I_TAIL, \
+		MSGPACK_PP_SEQ_FOR_EACH_O_I_NIL \
+		) \
+	(seq), \
+	sz \
+	) \
+/**/
+# define MSGPACK_PP_SEQ_FOR_EACH_O_I_TAIL(seq) MSGPACK_PP_SEQ_TAIL(seq)
+# define MSGPACK_PP_SEQ_FOR_EACH_O_I_NIL(seq) MSGPACK_PP_NIL
 #
 # if MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_STRICT()
-#    define MSGPACK_PP_SEQ_FOR_EACH_M(r, x) MSGPACK_PP_SEQ_FOR_EACH_M_IM(r, MSGPACK_PP_TUPLE_REM_3 x)
+#    define MSGPACK_PP_SEQ_FOR_EACH_M(r, x) MSGPACK_PP_SEQ_FOR_EACH_M_IM(r, MSGPACK_PP_TUPLE_REM_4 x)
 #    define MSGPACK_PP_SEQ_FOR_EACH_M_IM(r, im) MSGPACK_PP_SEQ_FOR_EACH_M_I(r, im)
 # else
-#    define MSGPACK_PP_SEQ_FOR_EACH_M(r, x) MSGPACK_PP_SEQ_FOR_EACH_M_I(r, MSGPACK_PP_TUPLE_ELEM(3, 0, x), MSGPACK_PP_TUPLE_ELEM(3, 1, x), MSGPACK_PP_TUPLE_ELEM(3, 2, x))
+#    define MSGPACK_PP_SEQ_FOR_EACH_M(r, x) MSGPACK_PP_SEQ_FOR_EACH_M_I(r, MSGPACK_PP_TUPLE_ELEM(4, 0, x), MSGPACK_PP_TUPLE_ELEM(4, 1, x), MSGPACK_PP_TUPLE_ELEM(4, 2, x), MSGPACK_PP_TUPLE_ELEM(4, 3, x))
 # endif
 #
-# define MSGPACK_PP_SEQ_FOR_EACH_M_I(r, macro, data, seq) macro(r, data, MSGPACK_PP_SEQ_HEAD(seq))
+# define MSGPACK_PP_SEQ_FOR_EACH_M_I(r, macro, data, seq, sz) macro(r, data, MSGPACK_PP_SEQ_HEAD(seq))
 #
 # /* MSGPACK_PP_SEQ_FOR_EACH_R */
 #
 # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG()
-#    define MSGPACK_PP_SEQ_FOR_EACH_R(r, macro, data, seq) MSGPACK_PP_FOR_ ## r((macro, data, seq (nil)), MSGPACK_PP_SEQ_FOR_EACH_P, MSGPACK_PP_SEQ_FOR_EACH_O, MSGPACK_PP_SEQ_FOR_EACH_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_R(r, macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_R(r, macro, data, seq)
 # else
 #    define MSGPACK_PP_SEQ_FOR_EACH_R(r, macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_R_I(r, macro, data, seq)
-#    define MSGPACK_PP_SEQ_FOR_EACH_R_I(r, macro, data, seq) MSGPACK_PP_FOR_ ## r((macro, data, seq (nil)), MSGPACK_PP_SEQ_FOR_EACH_P, MSGPACK_PP_SEQ_FOR_EACH_O, MSGPACK_PP_SEQ_FOR_EACH_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_R_I(r, macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_R(r, macro, data, seq)
 # endif
 #
+#    define MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC_R(r, macro, data, seq) MSGPACK_PP_FOR_ ## r((macro, data, seq, MSGPACK_PP_SEQ_SIZE(seq)), MSGPACK_PP_SEQ_FOR_EACH_P, MSGPACK_PP_SEQ_FOR_EACH_O, MSGPACK_PP_SEQ_FOR_EACH_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY_R(r, macro, data, seq)
+#
+#    define MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_R(r, macro, data, seq) \
+		MSGPACK_PP_IIF \
+			( \
+			MSGPACK_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
+			MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC_R, \
+			MSGPACK_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY_R \
+			) \
+		(r, macro, data, seq) \
+/**/
+#
 # endif

data/vendor/local/include/msgpack/preprocessor/seq/for_each_i.hpp

@@ -15,47 +15,95 @@
 # include <msgpack/preprocessor/arithmetic/dec.hpp>
 # include <msgpack/preprocessor/arithmetic/inc.hpp>
 # include <msgpack/preprocessor/config/config.hpp>
+# include <msgpack/preprocessor/control/if.hpp>
+# include <msgpack/preprocessor/control/iif.hpp>
 # include <msgpack/preprocessor/repetition/for.hpp>
 # include <msgpack/preprocessor/seq/seq.hpp>
 # include <msgpack/preprocessor/seq/size.hpp>
+# include <msgpack/preprocessor/seq/detail/is_empty.hpp>
 # include <msgpack/preprocessor/tuple/elem.hpp>
 # include <msgpack/preprocessor/tuple/rem.hpp>
 #
 # /* MSGPACK_PP_SEQ_FOR_EACH_I */
 #
 # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG()
-#    define MSGPACK_PP_SEQ_FOR_EACH_I(macro, data, seq) MSGPACK_PP_FOR((macro, data, seq (nil), 0), MSGPACK_PP_SEQ_FOR_EACH_I_P, MSGPACK_PP_SEQ_FOR_EACH_I_O, MSGPACK_PP_SEQ_FOR_EACH_I_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_I(macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_I_DETAIL_CHECK(macro, data, seq)
 # else
 #    define MSGPACK_PP_SEQ_FOR_EACH_I(macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_I_I(macro, data, seq)
-#    define MSGPACK_PP_SEQ_FOR_EACH_I_I(macro, data, seq) MSGPACK_PP_FOR((macro, data, seq (nil), 0), MSGPACK_PP_SEQ_FOR_EACH_I_P, MSGPACK_PP_SEQ_FOR_EACH_I_O, MSGPACK_PP_SEQ_FOR_EACH_I_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_I(macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_I_DETAIL_CHECK(macro, data, seq)
 # endif
 #
-# define MSGPACK_PP_SEQ_FOR_EACH_I_P(r, x) MSGPACK_PP_DEC(MSGPACK_PP_SEQ_SIZE(MSGPACK_PP_TUPLE_ELEM(4, 2, x)))
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EXEC(macro, data, seq) MSGPACK_PP_FOR((macro, data, seq, 0, MSGPACK_PP_SEQ_SIZE(seq)), MSGPACK_PP_SEQ_FOR_EACH_I_P, MSGPACK_PP_SEQ_FOR_EACH_I_O, MSGPACK_PP_SEQ_FOR_EACH_I_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EMPTY(macro, data, seq)
+#
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_DETAIL_CHECK(macro, data, seq) \
+		MSGPACK_PP_IIF \
+			( \
+			MSGPACK_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
+			MSGPACK_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EXEC, \
+			MSGPACK_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EMPTY \
+			) \
+		(macro, data, seq) \
+/**/
+#
+# define MSGPACK_PP_SEQ_FOR_EACH_I_P(r, x) MSGPACK_PP_TUPLE_ELEM(5, 4, x)
 #
 # if MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_STRICT()
 #    define MSGPACK_PP_SEQ_FOR_EACH_I_O(r, x) MSGPACK_PP_SEQ_FOR_EACH_I_O_I x
 # else
-#    define MSGPACK_PP_SEQ_FOR_EACH_I_O(r, x) MSGPACK_PP_SEQ_FOR_EACH_I_O_I(MSGPACK_PP_TUPLE_ELEM(4, 0, x), MSGPACK_PP_TUPLE_ELEM(4, 1, x), MSGPACK_PP_TUPLE_ELEM(4, 2, x), MSGPACK_PP_TUPLE_ELEM(4, 3, x))
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_O(r, x) MSGPACK_PP_SEQ_FOR_EACH_I_O_I(MSGPACK_PP_TUPLE_ELEM(5, 0, x), MSGPACK_PP_TUPLE_ELEM(5, 1, x), MSGPACK_PP_TUPLE_ELEM(5, 2, x), MSGPACK_PP_TUPLE_ELEM(5, 3, x), MSGPACK_PP_TUPLE_ELEM(5, 4, x))
 # endif
 #
-# define MSGPACK_PP_SEQ_FOR_EACH_I_O_I(macro, data, seq, i) (macro, data, MSGPACK_PP_SEQ_TAIL(seq), MSGPACK_PP_INC(i))
+# define MSGPACK_PP_SEQ_FOR_EACH_I_O_I(macro, data, seq, i, sz) \
+	MSGPACK_PP_SEQ_FOR_EACH_I_O_I_DEC(macro, data, seq, i, MSGPACK_PP_DEC(sz)) \
+/**/
+# define MSGPACK_PP_SEQ_FOR_EACH_I_O_I_DEC(macro, data, seq, i, sz) \
+	( \
+	macro, \
+	data, \
+	MSGPACK_PP_IF \
+		( \
+		sz, \
+		MSGPACK_PP_SEQ_FOR_EACH_I_O_I_TAIL, \
+		MSGPACK_PP_SEQ_FOR_EACH_I_O_I_NIL \
+		) \
+	(seq), \
+	MSGPACK_PP_INC(i), \
+	sz \
+	) \
+/**/
+# define MSGPACK_PP_SEQ_FOR_EACH_I_O_I_TAIL(seq) MSGPACK_PP_SEQ_TAIL(seq)
+# define MSGPACK_PP_SEQ_FOR_EACH_I_O_I_NIL(seq) MSGPACK_PP_NIL
 #
 # if MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_STRICT()
-#    define MSGPACK_PP_SEQ_FOR_EACH_I_M(r, x) MSGPACK_PP_SEQ_FOR_EACH_I_M_IM(r, MSGPACK_PP_TUPLE_REM_4 x)
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_M(r, x) MSGPACK_PP_SEQ_FOR_EACH_I_M_IM(r, MSGPACK_PP_TUPLE_REM_5 x)
 #    define MSGPACK_PP_SEQ_FOR_EACH_I_M_IM(r, im) MSGPACK_PP_SEQ_FOR_EACH_I_M_I(r, im)
 # else
-#    define MSGPACK_PP_SEQ_FOR_EACH_I_M(r, x) MSGPACK_PP_SEQ_FOR_EACH_I_M_I(r, MSGPACK_PP_TUPLE_ELEM(4, 0, x), MSGPACK_PP_TUPLE_ELEM(4, 1, x), MSGPACK_PP_TUPLE_ELEM(4, 2, x), MSGPACK_PP_TUPLE_ELEM(4, 3, x))
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_M(r, x) MSGPACK_PP_SEQ_FOR_EACH_I_M_I(r, MSGPACK_PP_TUPLE_ELEM(5, 0, x), MSGPACK_PP_TUPLE_ELEM(5, 1, x), MSGPACK_PP_TUPLE_ELEM(5, 2, x), MSGPACK_PP_TUPLE_ELEM(5, 3, x), MSGPACK_PP_TUPLE_ELEM(5, 4, x))
 # endif
 #
-# define MSGPACK_PP_SEQ_FOR_EACH_I_M_I(r, macro, data, seq, i) macro(r, data, i, MSGPACK_PP_SEQ_HEAD(seq))
+# define MSGPACK_PP_SEQ_FOR_EACH_I_M_I(r, macro, data, seq, i, sz) macro(r, data, i, MSGPACK_PP_SEQ_HEAD(seq))
 #
 # /* MSGPACK_PP_SEQ_FOR_EACH_I_R */
 #
 # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG()
-#    define MSGPACK_PP_SEQ_FOR_EACH_I_R(r, macro, data, seq) MSGPACK_PP_FOR_ ## r((macro, data, seq (nil), 0), MSGPACK_PP_SEQ_FOR_EACH_I_P, MSGPACK_PP_SEQ_FOR_EACH_I_O, MSGPACK_PP_SEQ_FOR_EACH_I_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_R(r, macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK(r, macro, data, seq)
 # else
 #    define MSGPACK_PP_SEQ_FOR_EACH_I_R(r, macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_I_R_I(r, macro, data, seq)
-#    define MSGPACK_PP_SEQ_FOR_EACH_I_R_I(r, macro, data, seq) MSGPACK_PP_FOR_ ## r((macro, data, seq (nil), 0), MSGPACK_PP_SEQ_FOR_EACH_I_P, MSGPACK_PP_SEQ_FOR_EACH_I_O, MSGPACK_PP_SEQ_FOR_EACH_I_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_R_I(r, macro, data, seq) MSGPACK_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK(r, macro, data, seq)
 # endif
 #
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EXEC(r, macro, data, seq) MSGPACK_PP_FOR_ ## r((macro, data, seq, 0, MSGPACK_PP_SEQ_SIZE(seq)), MSGPACK_PP_SEQ_FOR_EACH_I_P, MSGPACK_PP_SEQ_FOR_EACH_I_O, MSGPACK_PP_SEQ_FOR_EACH_I_M)
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EMPTY(r, macro, data, seq)
+#
+#    define MSGPACK_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK(r, macro, data, seq) \
+		MSGPACK_PP_IIF \
+			( \
+			MSGPACK_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), \
+			MSGPACK_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EXEC, \
+			MSGPACK_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EMPTY \
+			) \
+		(r, macro, data, seq) \
+/**/
+#
 # endif

data/vendor/local/include/msgpack/preprocessor/seq/replace.hpp

@@ -12,18 +12,34 @@
 # ifndef MSGPACK_PREPROCESSOR_SEQ_REPLACE_HPP
 # define MSGPACK_PREPROCESSOR_SEQ_REPLACE_HPP
 #
+# include <msgpack/preprocessor/arithmetic/dec.hpp>
 # include <msgpack/preprocessor/arithmetic/inc.hpp>
 # include <msgpack/preprocessor/config/config.hpp>
+# include <msgpack/preprocessor/comparison/equal.hpp>
+# include <msgpack/preprocessor/control/iif.hpp>
 # include <msgpack/preprocessor/seq/first_n.hpp>
 # include <msgpack/preprocessor/seq/rest_n.hpp>
+# include <msgpack/preprocessor/seq/size.hpp>
 #
 # /* MSGPACK_PP_SEQ_REPLACE */
 #
 # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG()
-#    define MSGPACK_PP_SEQ_REPLACE(seq, i, elem) MSGPACK_PP_SEQ_FIRST_N(i, seq) (elem) MSGPACK_PP_SEQ_REST_N(MSGPACK_PP_INC(i), seq)
+#    define MSGPACK_PP_SEQ_REPLACE(seq, i, elem) MSGPACK_PP_SEQ_FIRST_N(i, seq) (elem) MSGPACK_PP_SEQ_REPLACE_DETAIL_REST(seq, i)
 # else
 #    define MSGPACK_PP_SEQ_REPLACE(seq, i, elem) MSGPACK_PP_SEQ_REPLACE_I(seq, i, elem)
-#    define MSGPACK_PP_SEQ_REPLACE_I(seq, i, elem) MSGPACK_PP_SEQ_FIRST_N(i, seq) (elem) MSGPACK_PP_SEQ_REST_N(MSGPACK_PP_INC(i), seq)
+#    define MSGPACK_PP_SEQ_REPLACE_I(seq, i, elem) MSGPACK_PP_SEQ_FIRST_N(i, seq) (elem) MSGPACK_PP_SEQ_REPLACE_DETAIL_REST(seq, i)
 # endif
 #
+#    define MSGPACK_PP_SEQ_REPLACE_DETAIL_REST_EMPTY(seq, i)
+#    define MSGPACK_PP_SEQ_REPLACE_DETAIL_REST_VALID(seq, i) MSGPACK_PP_SEQ_REST_N(MSGPACK_PP_INC(i), seq)
+#    define MSGPACK_PP_SEQ_REPLACE_DETAIL_REST(seq, i) \
+		MSGPACK_PP_IIF \
+			( \
+			MSGPACK_PP_EQUAL(i,MSGPACK_PP_DEC(MSGPACK_PP_SEQ_SIZE(seq))), \
+			MSGPACK_PP_SEQ_REPLACE_DETAIL_REST_EMPTY, \
+			MSGPACK_PP_SEQ_REPLACE_DETAIL_REST_VALID \
+			) \
+		(seq, i) \
+/**/
+#
 # endif

data/vendor/local/include/msgpack/preprocessor/seq/rest_n.hpp

@@ -13,18 +13,34 @@
 # define MSGPACK_PREPROCESSOR_SEQ_REST_N_HPP
 #
 # include <msgpack/preprocessor/arithmetic/inc.hpp>
+# include <msgpack/preprocessor/comparison/not_equal.hpp>
 # include <msgpack/preprocessor/config/config.hpp>
+# include <msgpack/preprocessor/control/expr_iif.hpp>
 # include <msgpack/preprocessor/facilities/identity.hpp>
+# include <msgpack/preprocessor/logical/bitand.hpp>
+# include <msgpack/preprocessor/seq/detail/is_empty.hpp>
 # include <msgpack/preprocessor/seq/detail/split.hpp>
 # include <msgpack/preprocessor/tuple/elem.hpp>
 #
 # /* MSGPACK_PP_SEQ_REST_N */
 #
 # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG()
-#    define MSGPACK_PP_SEQ_REST_N(n, seq) MSGPACK_PP_TUPLE_ELEM(2, 1, MSGPACK_PP_SEQ_SPLIT(MSGPACK_PP_INC(n), MSGPACK_PP_IDENTITY( (nil) seq )))()
+#    define MSGPACK_PP_SEQ_REST_N(n, seq) MSGPACK_PP_SEQ_REST_N_DETAIL_EXEC(n, seq, MSGPACK_PP_SEQ_DETAIL_EMPTY_SIZE(seq))
 # else
 #    define MSGPACK_PP_SEQ_REST_N(n, seq) MSGPACK_PP_SEQ_REST_N_I(n, seq)
-#    define MSGPACK_PP_SEQ_REST_N_I(n, seq) MSGPACK_PP_TUPLE_ELEM(2, 1, MSGPACK_PP_SEQ_SPLIT(MSGPACK_PP_INC(n), MSGPACK_PP_IDENTITY( (nil) seq )))()
+#    define MSGPACK_PP_SEQ_REST_N_I(n, seq) MSGPACK_PP_SEQ_REST_N_DETAIL_EXEC(n, seq, MSGPACK_PP_SEQ_DETAIL_EMPTY_SIZE(seq))
 # endif
 #
+#    define MSGPACK_PP_SEQ_REST_N_DETAIL_EXEC(n, seq, size) \
+		MSGPACK_PP_EXPR_IIF \
+			( \
+			MSGPACK_PP_BITAND \
+				( \
+				MSGPACK_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(size), \
+				MSGPACK_PP_NOT_EQUAL(n,size) \
+				), \
+			MSGPACK_PP_TUPLE_ELEM(2, 1, MSGPACK_PP_SEQ_SPLIT(MSGPACK_PP_INC(n), MSGPACK_PP_IDENTITY( (nil) seq )))() \
+			) \
+/**/
+#
 # endif

data/vendor/local/include/msgpack/preprocessor/seq/size.hpp

@@ -543,5 +543,6 @@
 # define MSGPACK_PP_SEQ_SIZE_MSGPACK_PP_SEQ_SIZE_254 254
 # define MSGPACK_PP_SEQ_SIZE_MSGPACK_PP_SEQ_SIZE_255 255
 # define MSGPACK_PP_SEQ_SIZE_MSGPACK_PP_SEQ_SIZE_256 256
+# define MSGPACK_PP_SEQ_SIZE_MSGPACK_PP_SEQ_SIZE_257 257
 #
 # endif

data/vendor/local/include/msgpack/preprocessor/tuple/eat.hpp

@@ -8,7 +8,7 @@
 #  */
 #
 # /* Revised by Paul Mensonides (2002-2011) */
-# /* Revised by Edward Diener (2011) */
+# /* Revised by Edward Diener (2011,2015) */
 #
 # /* See http://www.boost.org for most recent version. */
 #
@@ -38,6 +38,15 @@
 #    endif
 #    define MSGPACK_PP_TUPLE_EAT_I(size) MSGPACK_PP_TUPLE_EAT_ ## size
 # endif
+#
+# if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_MWCC()
+#     define MSGPACK_PP_TUPLE_EAT_N(size) MSGPACK_PP_TUPLE_EAT_N_I(size)
+# else
+#     define MSGPACK_PP_TUPLE_EAT_N(size) MSGPACK_PP_TUPLE_EAT_N_OO((size))
+#     define MSGPACK_PP_TUPLE_EAT_N_OO(par) MSGPACK_PP_TUPLE_EAT_N_I ## par
+# endif
+# define MSGPACK_PP_TUPLE_EAT_N_I(size) MSGPACK_PP_TUPLE_EAT_ ## size
+#
 # define MSGPACK_PP_TUPLE_EAT_1(e0)
 # define MSGPACK_PP_TUPLE_EAT_2(e0, e1)
 # define MSGPACK_PP_TUPLE_EAT_3(e0, e1, e2)

data/vendor/local/include/msgpack/sbuffer.hpp

@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ simple buffer implementation
 //
-// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
+// Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,143 +10,8 @@
 #ifndef MSGPACK_SBUFFER_HPP
 #define MSGPACK_SBUFFER_HPP
 
-#include "msgpack/versioning.hpp"
+#include "msgpack/sbuffer_decl.hpp"
 
-#include <stdexcept>
+#include "msgpack/v1/sbuffer.hpp"
 
-#ifndef MSGPACK_SBUFFER_INIT_SIZE
-#define MSGPACK_SBUFFER_INIT_SIZE 8192
-#endif
-
-namespace msgpack {
-
-/// @cond
-MSGPACK_API_VERSION_NAMESPACE(v1) {
-/// @endcond
-
-class sbuffer {
-public:
-    sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):m_size(0), m_alloc(initsz)
-    {
-        if(initsz == 0) {
-            m_data = nullptr;
-        } else {
-            m_data = (char*)::malloc(initsz);
-            if(!m_data) {
-                throw std::bad_alloc();
-            }
-        }
-    }
-
-    ~sbuffer()
-    {
-        ::free(m_data);
-    }
-
-#if !defined(MSGPACK_USE_CPP03)
-    sbuffer(const sbuffer&) = delete;
-    sbuffer& operator=(const sbuffer&) = delete;
-
-    sbuffer(sbuffer&& other) :
-        m_size(other.m_size), m_data(other.m_data), m_alloc(other.m_alloc)
-    {
-        other.m_size = other.m_alloc = 0;
-        other.m_data = nullptr;
-    }
-
-    sbuffer& operator=(sbuffer&& other)
-    {
-        ::free(m_data);
-
-        m_size = other.m_size;
-        m_alloc = other.m_alloc;
-        m_data = other.m_data;
-
-        other.m_size = other.m_alloc = 0;
-        other.m_data = nullptr;
-
-        return *this;
-    }
-#endif // !defined(MSGPACK_USE_CPP03)
-
-    void write(const char* buf, size_t len)
-    {
-        if(m_alloc - m_size < len) {
-            expand_buffer(len);
-        }
-        std::memcpy(m_data + m_size, buf, len);
-        m_size += len;
-    }
-
-    char* data()
-    {
-        return m_data;
-    }
-
-    const char* data() const
-    {
-        return m_data;
-    }
-
-    size_t size() const
-    {
-        return m_size;
-    }
-
-    char* release()
-    {
-        char* tmp = m_data;
-        m_size = 0;
-        m_data = nullptr;
-        m_alloc = 0;
-        return tmp;
-    }
-
-    void clear()
-    {
-        m_size = 0;
-    }
-
-private:
-    void expand_buffer(size_t len)
-    {
-        size_t nsize = (m_alloc > 0) ?
-                m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE;
-
-        while(nsize < m_size + len) {
-            size_t tmp_nsize = nsize * 2;
-            if (tmp_nsize <= nsize) {
-                nsize = m_size + len;
-                break;
-            }
-            nsize = tmp_nsize;
-        }
-
-        void* tmp = ::realloc(m_data, nsize);
-        if(!tmp) {
-            throw std::bad_alloc();
-        }
-
-        m_data = static_cast<char*>(tmp);
-        m_alloc = nsize;
-    }
-
-#if defined(MSGPACK_USE_CPP03)
-private:
-    sbuffer(const sbuffer&);
-    sbuffer& operator=(const sbuffer&);
-#endif  // defined(MSGPACK_USE_CPP03)
-
-private:
-    size_t m_size;
-    char* m_data;
-    size_t m_alloc;
-};
-
-/// @cond
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
-/// @endcond
-
-}  // namespace msgpack
-
-#endif /* msgpack/sbuffer.hpp */
+#endif // MSGPACK_SBUFFER_HPP