├── .gitattributes ├── .gitignore ├── CMakeLists.txt ├── LICENSE ├── README.md ├── include ├── blib │ ├── bun │ │ ├── bun.hpp │ │ └── impl │ │ │ ├── CppTypeToSQLString.hpp │ │ │ ├── DbBackend.hpp │ │ │ ├── DbLogger.hpp │ │ │ ├── SimpleOID.hpp │ │ │ ├── endian.hpp │ │ │ ├── kv.hpp │ │ │ └── orm.hpp │ └── utils │ │ ├── MD5.hpp │ │ ├── Singleton.hpp │ │ └── debug.hpp └── third_party │ ├── fmt │ ├── format.hpp │ └── format_impl.hpp │ ├── hdr │ ├── sqlite_modern_cpp.hpp │ └── sqlite_modern_cpp │ │ ├── extensions │ │ ├── boost_json_spirit.hpp │ │ ├── boost_uuid.hpp │ │ └── std_time_t.hpp │ │ └── utility │ │ └── function_traits.hpp │ ├── json │ └── json.hpp │ ├── msgpack │ ├── msgpack.h │ ├── msgpack.hpp │ └── msgpack │ │ ├── adaptor │ │ ├── adaptor_base.hpp │ │ ├── adaptor_base_decl.hpp │ │ ├── array_ref.hpp │ │ ├── array_ref_decl.hpp │ │ ├── bool.hpp │ │ ├── boost │ │ │ ├── fusion.hpp │ │ │ ├── msgpack_variant.hpp │ │ │ ├── msgpack_variant_decl.hpp │ │ │ ├── optional.hpp │ │ │ ├── string_ref.hpp │ │ │ └── string_view.hpp │ │ ├── carray.hpp │ │ ├── char_ptr.hpp │ │ ├── check_container_size.hpp │ │ ├── check_container_size_decl.hpp │ │ ├── cpp11 │ │ │ ├── array.hpp │ │ │ ├── array_char.hpp │ │ │ ├── array_unsigned_char.hpp │ │ │ ├── forward_list.hpp │ │ │ ├── reference_wrapper.hpp │ │ │ ├── shared_ptr.hpp │ │ │ ├── tuple.hpp │ │ │ ├── unique_ptr.hpp │ │ │ ├── unordered_map.hpp │ │ │ └── unordered_set.hpp │ │ ├── cpp17 │ │ │ ├── optional.hpp │ │ │ └── string_view.hpp │ │ ├── define.hpp │ │ ├── define_decl.hpp │ │ ├── deque.hpp │ │ ├── ext.hpp │ │ ├── ext_decl.hpp │ │ ├── fixint.hpp │ │ ├── fixint_decl.hpp │ │ ├── float.hpp │ │ ├── int.hpp │ │ ├── int_decl.hpp │ │ ├── list.hpp │ │ ├── map.hpp │ │ ├── map_decl.hpp │ │ ├── msgpack_tuple.hpp │ │ ├── msgpack_tuple_decl.hpp │ │ ├── nil.hpp │ │ ├── nil_decl.hpp │ │ ├── pair.hpp │ │ ├── raw.hpp │ │ ├── raw_decl.hpp │ │ ├── set.hpp │ │ ├── size_equal_only.hpp │ │ ├── size_equal_only_decl.hpp │ │ ├── string.hpp │ │ ├── tr1 │ │ │ ├── unordered_map.hpp │ │ │ └── unordered_set.hpp │ │ ├── v4raw.hpp │ │ ├── v4raw_decl.hpp │ │ ├── vector.hpp │ │ ├── vector_bool.hpp │ │ ├── vector_char.hpp │ │ └── vector_unsigned_char.hpp │ │ ├── cpp_config.hpp │ │ ├── cpp_config_decl.hpp │ │ ├── fbuffer.h │ │ ├── fbuffer.hpp │ │ ├── fbuffer_decl.hpp │ │ ├── gcc_atomic.h │ │ ├── gcc_atomic.hpp │ │ ├── iterator.hpp │ │ ├── iterator_decl.hpp │ │ ├── meta.hpp │ │ ├── meta_decl.hpp │ │ ├── object.h │ │ ├── object.hpp │ │ ├── object_decl.hpp │ │ ├── object_fwd.hpp │ │ ├── object_fwd_decl.hpp │ │ ├── pack.h │ │ ├── pack.hpp │ │ ├── pack_decl.hpp │ │ ├── pack_define.h │ │ ├── pack_template.h │ │ ├── parse_return.hpp │ │ ├── predef.h │ │ ├── predef │ │ ├── architecture.h │ │ ├── architecture │ │ │ ├── alpha.h │ │ │ ├── arm.h │ │ │ ├── blackfin.h │ │ │ ├── convex.h │ │ │ ├── ia64.h │ │ │ ├── m68k.h │ │ │ ├── mips.h │ │ │ ├── parisc.h │ │ │ ├── ppc.h │ │ │ ├── pyramid.h │ │ │ ├── rs6k.h │ │ │ ├── sparc.h │ │ │ ├── superh.h │ │ │ ├── sys370.h │ │ │ ├── sys390.h │ │ │ ├── x86.h │ │ │ ├── x86 │ │ │ │ ├── 32.h │ │ │ │ └── 64.h │ │ │ └── z.h │ │ ├── compiler.h │ │ ├── compiler │ │ │ ├── borland.h │ │ │ ├── clang.h │ │ │ ├── comeau.h │ │ │ ├── compaq.h │ │ │ ├── diab.h │ │ │ ├── digitalmars.h │ │ │ ├── dignus.h │ │ │ ├── edg.h │ │ │ ├── ekopath.h │ │ │ ├── gcc.h │ │ │ ├── gcc_xml.h │ │ │ ├── greenhills.h │ │ │ ├── hp_acc.h │ │ │ ├── iar.h │ │ │ ├── ibm.h │ │ │ ├── intel.h │ │ │ ├── kai.h │ │ │ ├── llvm.h │ │ │ ├── metaware.h │ │ │ ├── metrowerks.h │ │ │ ├── microtec.h │ │ │ ├── mpw.h │ │ │ ├── palm.h │ │ │ ├── pgi.h │ │ │ ├── sgi_mipspro.h │ │ │ ├── sunpro.h │ │ │ ├── tendra.h │ │ │ ├── visualc.h │ │ │ └── watcom.h │ │ ├── detail │ │ │ ├── _cassert.h │ │ │ ├── _exception.h │ │ │ ├── comp_detected.h │ │ │ ├── endian_compat.h │ │ │ ├── os_detected.h │ │ │ ├── platform_detected.h │ │ │ ├── test.h │ │ │ └── test_def.h │ │ ├── hardware.h │ │ ├── hardware │ │ │ ├── simd.h │ │ │ └── simd │ │ │ │ ├── arm.h │ │ │ │ ├── arm │ │ │ │ └── versions.h │ │ │ │ ├── ppc.h │ │ │ │ ├── ppc │ │ │ │ └── versions.h │ │ │ │ ├── x86.h │ │ │ │ ├── x86 │ │ │ │ └── versions.h │ │ │ │ ├── x86_amd.h │ │ │ │ └── x86_amd │ │ │ │ └── versions.h │ │ ├── language.h │ │ ├── language │ │ │ ├── objc.h │ │ │ ├── stdc.h │ │ │ └── stdcpp.h │ │ ├── library.h │ │ ├── library │ │ │ ├── c.h │ │ │ ├── c │ │ │ │ ├── _prefix.h │ │ │ │ ├── gnu.h │ │ │ │ ├── uc.h │ │ │ │ ├── vms.h │ │ │ │ └── zos.h │ │ │ ├── std.h │ │ │ └── std │ │ │ │ ├── _prefix.h │ │ │ │ ├── cxx.h │ │ │ │ ├── dinkumware.h │ │ │ │ ├── libcomo.h │ │ │ │ ├── modena.h │ │ │ │ ├── msl.h │ │ │ │ ├── roguewave.h │ │ │ │ ├── sgi.h │ │ │ │ ├── stdcpp3.h │ │ │ │ ├── stlport.h │ │ │ │ └── vacpp.h │ │ ├── make.h │ │ ├── os.h │ │ ├── os │ │ │ ├── aix.h │ │ │ ├── amigaos.h │ │ │ ├── android.h │ │ │ ├── beos.h │ │ │ ├── bsd.h │ │ │ ├── bsd │ │ │ │ ├── bsdi.h │ │ │ │ ├── dragonfly.h │ │ │ │ ├── free.h │ │ │ │ ├── net.h │ │ │ │ └── open.h │ │ │ ├── cygwin.h │ │ │ ├── haiku.h │ │ │ ├── hpux.h │ │ │ ├── ios.h │ │ │ ├── irix.h │ │ │ ├── linux.h │ │ │ ├── macos.h │ │ │ ├── os400.h │ │ │ ├── qnxnto.h │ │ │ ├── solaris.h │ │ │ ├── unix.h │ │ │ ├── vms.h │ │ │ └── windows.h │ │ ├── other.h │ │ ├── other │ │ │ └── endian.h │ │ ├── platform.h │ │ ├── platform │ │ │ ├── mingw.h │ │ │ ├── windows_desktop.h │ │ │ ├── windows_phone.h │ │ │ ├── windows_runtime.h │ │ │ └── windows_store.h │ │ ├── version.h │ │ └── version_number.h │ │ ├── preprocessor.hpp │ │ ├── preprocessor │ │ ├── arithmetic.hpp │ │ ├── arithmetic │ │ │ ├── add.hpp │ │ │ ├── dec.hpp │ │ │ ├── detail │ │ │ │ └── div_base.hpp │ │ │ ├── div.hpp │ │ │ ├── inc.hpp │ │ │ ├── mod.hpp │ │ │ ├── mul.hpp │ │ │ └── sub.hpp │ │ ├── array.hpp │ │ ├── array │ │ │ ├── data.hpp │ │ │ ├── detail │ │ │ │ └── get_data.hpp │ │ │ ├── elem.hpp │ │ │ ├── enum.hpp │ │ │ ├── insert.hpp │ │ │ ├── pop_back.hpp │ │ │ ├── pop_front.hpp │ │ │ ├── push_back.hpp │ │ │ ├── push_front.hpp │ │ │ ├── remove.hpp │ │ │ ├── replace.hpp │ │ │ ├── reverse.hpp │ │ │ ├── size.hpp │ │ │ ├── to_list.hpp │ │ │ ├── to_seq.hpp │ │ │ └── to_tuple.hpp │ │ ├── assert_msg.hpp │ │ ├── cat.hpp │ │ ├── comma.hpp │ │ ├── comma_if.hpp │ │ ├── comparison.hpp │ │ ├── comparison │ │ │ ├── equal.hpp │ │ │ ├── greater.hpp │ │ │ ├── greater_equal.hpp │ │ │ ├── less.hpp │ │ │ ├── less_equal.hpp │ │ │ └── not_equal.hpp │ │ ├── config │ │ │ ├── config.hpp │ │ │ └── limits.hpp │ │ ├── control.hpp │ │ ├── control │ │ │ ├── deduce_d.hpp │ │ │ ├── detail │ │ │ │ ├── dmc │ │ │ │ │ └── while.hpp │ │ │ │ ├── edg │ │ │ │ │ └── while.hpp │ │ │ │ ├── msvc │ │ │ │ │ └── while.hpp │ │ │ │ └── while.hpp │ │ │ ├── expr_if.hpp │ │ │ ├── expr_iif.hpp │ │ │ ├── if.hpp │ │ │ ├── iif.hpp │ │ │ └── while.hpp │ │ ├── debug.hpp │ │ ├── debug │ │ │ ├── assert.hpp │ │ │ ├── error.hpp │ │ │ └── line.hpp │ │ ├── dec.hpp │ │ ├── detail │ │ │ ├── auto_rec.hpp │ │ │ ├── check.hpp │ │ │ ├── dmc │ │ │ │ └── auto_rec.hpp │ │ │ ├── is_binary.hpp │ │ │ ├── is_nullary.hpp │ │ │ ├── is_unary.hpp │ │ │ ├── null.hpp │ │ │ └── split.hpp │ │ ├── empty.hpp │ │ ├── enum.hpp │ │ ├── enum_params.hpp │ │ ├── enum_params_with_a_default.hpp │ │ ├── enum_params_with_defaults.hpp │ │ ├── enum_shifted.hpp │ │ ├── enum_shifted_params.hpp │ │ ├── expand.hpp │ │ ├── expr_if.hpp │ │ ├── facilities.hpp │ │ ├── facilities │ │ │ ├── apply.hpp │ │ │ ├── detail │ │ │ │ └── is_empty.hpp │ │ │ ├── empty.hpp │ │ │ ├── expand.hpp │ │ │ ├── identity.hpp │ │ │ ├── intercept.hpp │ │ │ ├── is_1.hpp │ │ │ ├── is_empty.hpp │ │ │ ├── is_empty_or_1.hpp │ │ │ ├── is_empty_variadic.hpp │ │ │ └── overload.hpp │ │ ├── for.hpp │ │ ├── identity.hpp │ │ ├── if.hpp │ │ ├── inc.hpp │ │ ├── iterate.hpp │ │ ├── iteration.hpp │ │ ├── iteration │ │ │ ├── detail │ │ │ │ ├── bounds │ │ │ │ │ ├── lower1.hpp │ │ │ │ │ ├── lower2.hpp │ │ │ │ │ ├── lower3.hpp │ │ │ │ │ ├── lower4.hpp │ │ │ │ │ ├── lower5.hpp │ │ │ │ │ ├── upper1.hpp │ │ │ │ │ ├── upper2.hpp │ │ │ │ │ ├── upper3.hpp │ │ │ │ │ ├── upper4.hpp │ │ │ │ │ └── upper5.hpp │ │ │ │ ├── finish.hpp │ │ │ │ ├── iter │ │ │ │ │ ├── forward1.hpp │ │ │ │ │ ├── forward2.hpp │ │ │ │ │ ├── forward3.hpp │ │ │ │ │ ├── forward4.hpp │ │ │ │ │ ├── forward5.hpp │ │ │ │ │ ├── reverse1.hpp │ │ │ │ │ ├── reverse2.hpp │ │ │ │ │ ├── reverse3.hpp │ │ │ │ │ ├── reverse4.hpp │ │ │ │ │ └── reverse5.hpp │ │ │ │ ├── local.hpp │ │ │ │ ├── rlocal.hpp │ │ │ │ ├── self.hpp │ │ │ │ └── start.hpp │ │ │ ├── iterate.hpp │ │ │ ├── local.hpp │ │ │ └── self.hpp │ │ ├── library.hpp │ │ ├── limits.hpp │ │ ├── list.hpp │ │ ├── list │ │ │ ├── adt.hpp │ │ │ ├── append.hpp │ │ │ ├── at.hpp │ │ │ ├── cat.hpp │ │ │ ├── detail │ │ │ │ ├── dmc │ │ │ │ │ └── fold_left.hpp │ │ │ │ ├── edg │ │ │ │ │ ├── fold_left.hpp │ │ │ │ │ └── fold_right.hpp │ │ │ │ ├── fold_left.hpp │ │ │ │ └── fold_right.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 │ │ │ ├── rest_n.hpp │ │ │ ├── reverse.hpp │ │ │ ├── size.hpp │ │ │ ├── to_array.hpp │ │ │ ├── to_seq.hpp │ │ │ ├── to_tuple.hpp │ │ │ └── transform.hpp │ │ ├── logical.hpp │ │ ├── logical │ │ │ ├── and.hpp │ │ │ ├── bitand.hpp │ │ │ ├── bitnor.hpp │ │ │ ├── bitor.hpp │ │ │ ├── bitxor.hpp │ │ │ ├── bool.hpp │ │ │ ├── compl.hpp │ │ │ ├── nor.hpp │ │ │ ├── not.hpp │ │ │ ├── or.hpp │ │ │ └── xor.hpp │ │ ├── max.hpp │ │ ├── min.hpp │ │ ├── punctuation.hpp │ │ ├── punctuation │ │ │ ├── comma.hpp │ │ │ ├── comma_if.hpp │ │ │ ├── detail │ │ │ │ └── is_begin_parens.hpp │ │ │ ├── is_begin_parens.hpp │ │ │ ├── paren.hpp │ │ │ ├── paren_if.hpp │ │ │ └── remove_parens.hpp │ │ ├── repeat.hpp │ │ ├── repeat_2nd.hpp │ │ ├── repeat_3rd.hpp │ │ ├── repeat_from_to.hpp │ │ ├── repeat_from_to_2nd.hpp │ │ ├── repeat_from_to_3rd.hpp │ │ ├── repetition.hpp │ │ ├── repetition │ │ │ ├── deduce_r.hpp │ │ │ ├── deduce_z.hpp │ │ │ ├── detail │ │ │ │ ├── dmc │ │ │ │ │ └── for.hpp │ │ │ │ ├── edg │ │ │ │ │ └── for.hpp │ │ │ │ ├── for.hpp │ │ │ │ └── msvc │ │ │ │ │ └── for.hpp │ │ │ ├── enum.hpp │ │ │ ├── enum_binary_params.hpp │ │ │ ├── enum_params.hpp │ │ │ ├── enum_params_with_a_default.hpp │ │ │ ├── enum_params_with_defaults.hpp │ │ │ ├── enum_shifted.hpp │ │ │ ├── enum_shifted_binary_params.hpp │ │ │ ├── enum_shifted_params.hpp │ │ │ ├── enum_trailing.hpp │ │ │ ├── enum_trailing_binary_params.hpp │ │ │ ├── enum_trailing_params.hpp │ │ │ ├── for.hpp │ │ │ ├── repeat.hpp │ │ │ └── repeat_from_to.hpp │ │ ├── selection.hpp │ │ ├── selection │ │ │ ├── max.hpp │ │ │ └── min.hpp │ │ ├── seq.hpp │ │ ├── seq │ │ │ ├── cat.hpp │ │ │ ├── detail │ │ │ │ ├── binary_transform.hpp │ │ │ │ ├── is_empty.hpp │ │ │ │ └── split.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 │ │ │ ├── seq.hpp │ │ │ ├── size.hpp │ │ │ ├── subseq.hpp │ │ │ ├── to_array.hpp │ │ │ ├── to_list.hpp │ │ │ ├── to_tuple.hpp │ │ │ ├── transform.hpp │ │ │ └── variadic_seq_to_seq.hpp │ │ ├── slot.hpp │ │ ├── slot │ │ │ ├── counter.hpp │ │ │ ├── detail │ │ │ │ ├── counter.hpp │ │ │ │ ├── def.hpp │ │ │ │ ├── shared.hpp │ │ │ │ ├── slot1.hpp │ │ │ │ ├── slot2.hpp │ │ │ │ ├── slot3.hpp │ │ │ │ ├── slot4.hpp │ │ │ │ └── slot5.hpp │ │ │ └── slot.hpp │ │ ├── stringize.hpp │ │ ├── tuple.hpp │ │ ├── tuple │ │ │ ├── detail │ │ │ │ └── is_single_return.hpp │ │ │ ├── eat.hpp │ │ │ ├── elem.hpp │ │ │ ├── enum.hpp │ │ │ ├── insert.hpp │ │ │ ├── pop_back.hpp │ │ │ ├── pop_front.hpp │ │ │ ├── push_back.hpp │ │ │ ├── push_front.hpp │ │ │ ├── rem.hpp │ │ │ ├── remove.hpp │ │ │ ├── replace.hpp │ │ │ ├── reverse.hpp │ │ │ ├── size.hpp │ │ │ ├── to_array.hpp │ │ │ ├── to_list.hpp │ │ │ └── to_seq.hpp │ │ ├── variadic.hpp │ │ ├── variadic │ │ │ ├── detail │ │ │ │ └── is_single_return.hpp │ │ │ ├── elem.hpp │ │ │ ├── size.hpp │ │ │ ├── to_array.hpp │ │ │ ├── to_list.hpp │ │ │ ├── to_seq.hpp │ │ │ └── to_tuple.hpp │ │ ├── while.hpp │ │ └── wstringize.hpp │ │ ├── sbuffer.h │ │ ├── sbuffer.hpp │ │ ├── sbuffer_decl.hpp │ │ ├── sysdep.h │ │ ├── type.hpp │ │ ├── unpack.h │ │ ├── unpack.hpp │ │ ├── unpack_decl.hpp │ │ ├── unpack_define.h │ │ ├── unpack_exception.hpp │ │ ├── unpack_template.h │ │ ├── util.h │ │ ├── v1 │ │ ├── adaptor │ │ │ ├── adaptor_base.hpp │ │ │ ├── adaptor_base_decl.hpp │ │ │ ├── array_ref.hpp │ │ │ ├── array_ref_decl.hpp │ │ │ ├── bool.hpp │ │ │ ├── boost │ │ │ │ ├── fusion.hpp │ │ │ │ ├── msgpack_variant.hpp │ │ │ │ ├── msgpack_variant_decl.hpp │ │ │ │ ├── optional.hpp │ │ │ │ ├── string_ref.hpp │ │ │ │ └── string_view.hpp │ │ │ ├── carray.hpp │ │ │ ├── char_ptr.hpp │ │ │ ├── check_container_size.hpp │ │ │ ├── check_container_size_decl.hpp │ │ │ ├── cpp11 │ │ │ │ ├── array.hpp │ │ │ │ ├── array_char.hpp │ │ │ │ ├── array_unsigned_char.hpp │ │ │ │ ├── forward_list.hpp │ │ │ │ ├── reference_wrapper.hpp │ │ │ │ ├── shared_ptr.hpp │ │ │ │ ├── tuple.hpp │ │ │ │ ├── unique_ptr.hpp │ │ │ │ ├── unordered_map.hpp │ │ │ │ └── unordered_set.hpp │ │ │ ├── cpp17 │ │ │ │ ├── optional.hpp │ │ │ │ └── string_view.hpp │ │ │ ├── define.hpp │ │ │ ├── define_decl.hpp │ │ │ ├── deque.hpp │ │ │ ├── detail │ │ │ │ ├── cpp03_define_array.hpp │ │ │ │ ├── cpp03_define_array_decl.hpp │ │ │ │ ├── cpp03_define_map.hpp │ │ │ │ ├── cpp03_define_map_decl.hpp │ │ │ │ ├── cpp03_msgpack_tuple.hpp │ │ │ │ ├── cpp03_msgpack_tuple_decl.hpp │ │ │ │ ├── cpp11_convert_helper.hpp │ │ │ │ ├── cpp11_define_array.hpp │ │ │ │ ├── cpp11_define_array_decl.hpp │ │ │ │ ├── cpp11_define_map.hpp │ │ │ │ ├── cpp11_define_map_decl.hpp │ │ │ │ ├── cpp11_msgpack_tuple.hpp │ │ │ │ └── cpp11_msgpack_tuple_decl.hpp │ │ │ ├── ext.hpp │ │ │ ├── ext_decl.hpp │ │ │ ├── fixint.hpp │ │ │ ├── fixint_decl.hpp │ │ │ ├── float.hpp │ │ │ ├── int.hpp │ │ │ ├── int_decl.hpp │ │ │ ├── list.hpp │ │ │ ├── map.hpp │ │ │ ├── map_decl.hpp │ │ │ ├── msgpack_tuple.hpp │ │ │ ├── msgpack_tuple_decl.hpp │ │ │ ├── nil.hpp │ │ │ ├── nil_decl.hpp │ │ │ ├── pair.hpp │ │ │ ├── raw.hpp │ │ │ ├── raw_decl.hpp │ │ │ ├── set.hpp │ │ │ ├── size_equal_only.hpp │ │ │ ├── size_equal_only_decl.hpp │ │ │ ├── string.hpp │ │ │ ├── tr1 │ │ │ │ ├── unordered_map.hpp │ │ │ │ └── unordered_set.hpp │ │ │ ├── v4raw.hpp │ │ │ ├── v4raw_decl.hpp │ │ │ ├── vector.hpp │ │ │ ├── vector_bool.hpp │ │ │ ├── vector_char.hpp │ │ │ └── vector_unsigned_char.hpp │ │ ├── cpp_config.hpp │ │ ├── cpp_config_decl.hpp │ │ ├── detail │ │ │ ├── cpp03_zone.hpp │ │ │ ├── cpp03_zone_decl.hpp │ │ │ ├── cpp11_zone.hpp │ │ │ └── cpp11_zone_decl.hpp │ │ ├── fbuffer.hpp │ │ ├── fbuffer_decl.hpp │ │ ├── iterator.hpp │ │ ├── iterator_decl.hpp │ │ ├── meta.hpp │ │ ├── meta_decl.hpp │ │ ├── object.hpp │ │ ├── object_decl.hpp │ │ ├── object_fwd.hpp │ │ ├── object_fwd_decl.hpp │ │ ├── pack.hpp │ │ ├── pack_decl.hpp │ │ ├── parse_return.hpp │ │ ├── preprocessor.hpp │ │ ├── sbuffer.hpp │ │ ├── sbuffer_decl.hpp │ │ ├── unpack.hpp │ │ ├── unpack_decl.hpp │ │ ├── unpack_exception.hpp │ │ ├── version.hpp │ │ ├── versioning.hpp │ │ ├── vrefbuffer.hpp │ │ ├── vrefbuffer_decl.hpp │ │ ├── zbuffer.hpp │ │ ├── zbuffer_decl.hpp │ │ ├── zone.hpp │ │ └── zone_decl.hpp │ │ ├── v2 │ │ ├── adaptor │ │ │ ├── adaptor_base.hpp │ │ │ ├── adaptor_base_decl.hpp │ │ │ ├── array_ref_decl.hpp │ │ │ ├── boost │ │ │ │ └── msgpack_variant_decl.hpp │ │ │ ├── check_container_size_decl.hpp │ │ │ ├── define_decl.hpp │ │ │ ├── detail │ │ │ │ ├── cpp03_define_array_decl.hpp │ │ │ │ ├── cpp03_define_map_decl.hpp │ │ │ │ ├── cpp03_msgpack_tuple_decl.hpp │ │ │ │ ├── cpp11_define_array_decl.hpp │ │ │ │ ├── cpp11_define_map_decl.hpp │ │ │ │ └── cpp11_msgpack_tuple_decl.hpp │ │ │ ├── ext_decl.hpp │ │ │ ├── fixint_decl.hpp │ │ │ ├── int_decl.hpp │ │ │ ├── map_decl.hpp │ │ │ ├── msgpack_tuple_decl.hpp │ │ │ ├── nil_decl.hpp │ │ │ ├── raw_decl.hpp │ │ │ ├── size_equal_only_decl.hpp │ │ │ └── v4raw_decl.hpp │ │ ├── cpp_config_decl.hpp │ │ ├── create_object_visitor.hpp │ │ ├── detail │ │ │ ├── cpp03_zone_decl.hpp │ │ │ └── cpp11_zone_decl.hpp │ │ ├── fbuffer_decl.hpp │ │ ├── iterator_decl.hpp │ │ ├── meta_decl.hpp │ │ ├── null_visitor.hpp │ │ ├── object.hpp │ │ ├── object_decl.hpp │ │ ├── object_fwd.hpp │ │ ├── object_fwd_decl.hpp │ │ ├── pack_decl.hpp │ │ ├── parse.hpp │ │ ├── parse_return.hpp │ │ ├── sbuffer_decl.hpp │ │ ├── unpack.hpp │ │ ├── unpack_decl.hpp │ │ ├── vrefbuffer_decl.hpp │ │ ├── x3_parse.hpp │ │ ├── x3_unpack.hpp │ │ ├── zbuffer_decl.hpp │ │ └── zone_decl.hpp │ │ ├── version.h │ │ ├── version.hpp │ │ ├── version_master.h │ │ ├── versioning.hpp │ │ ├── vrefbuffer.h │ │ ├── vrefbuffer.hpp │ │ ├── vrefbuffer_decl.hpp │ │ ├── zbuffer.h │ │ ├── zbuffer.hpp │ │ ├── zbuffer_decl.hpp │ │ ├── zone.h │ │ ├── zone.hpp │ │ └── zone_decl.hpp │ ├── rapidjson │ ├── allocators.h │ ├── document.h │ ├── encodedstream.h │ ├── encodings.h │ ├── error │ │ ├── en.h │ │ └── error.h │ ├── filereadstream.h │ ├── filewritestream.h │ ├── fwd.h │ ├── internal │ │ ├── biginteger.h │ │ ├── diyfp.h │ │ ├── dtoa.h │ │ ├── ieee754.h │ │ ├── itoa.h │ │ ├── meta.h │ │ ├── pow10.h │ │ ├── regex.h │ │ ├── stack.h │ │ ├── strfunc.h │ │ ├── strtod.h │ │ └── swap.h │ ├── istreamwrapper.h │ ├── memorybuffer.h │ ├── memorystream.h │ ├── msinttypes │ │ ├── inttypes.h │ │ └── stdint.h │ ├── ostreamwrapper.h │ ├── pointer.h │ ├── prettywriter.h │ ├── rapidjson.h │ ├── reader.h │ ├── schema.h │ ├── stream.h │ ├── stringbuffer.h │ └── writer.h │ ├── spdlog │ ├── async_logger.h │ ├── common.h │ ├── details │ │ ├── async_log_helper.h │ │ ├── async_logger_impl.h │ │ ├── file_helper.h │ │ ├── log_msg.h │ │ ├── logger_impl.h │ │ ├── mpmc_bounded_q.h │ │ ├── null_mutex.h │ │ ├── os.h │ │ ├── pattern_formatter_impl.h │ │ ├── registry.h │ │ └── spdlog_impl.h │ ├── fmt │ │ ├── bundled │ │ │ ├── ostream.cc │ │ │ ├── ostream.h │ │ │ └── printf.h │ │ ├── fmt.h │ │ └── ostr.h │ ├── formatter.h │ ├── logger.h │ ├── sinks │ │ ├── android_sink.h │ │ ├── ansicolor_sink.h │ │ ├── base_sink.h │ │ ├── dist_sink.h │ │ ├── file_sinks.h │ │ ├── msvc_sink.h │ │ ├── null_sink.h │ │ ├── ostream_sink.h │ │ ├── sink.h │ │ ├── stdout_sinks.h │ │ ├── syslog_sink.h │ │ └── wincolor_sink.h │ ├── spdlog.h │ └── tweakme.h │ ├── sqlite │ ├── sqlite3.h │ └── sqlite3ext.h │ └── unqlite │ └── unqlite.h ├── qt └── qt.pro ├── src ├── BoostHeaders.cpp ├── Bun.cpp ├── Generate.cpp ├── QueryExample.cpp ├── sqlite │ └── sqlite3.c └── unqlite.c └── vs ├── bun ├── ReadMe.txt ├── bun.cpp ├── bun.vcxproj ├── bun.vcxproj.filters └── bun.vcxproj.user └── vs.sln /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files 2 | *.slo 3 | *.lo 4 | *.o 5 | *.obj 6 | 7 | # Precompiled Headers 8 | *.gch 9 | *.pch 10 | 11 | # Compiled Dynamic libraries 12 | *.so 13 | *.dylib 14 | *.dll 15 | 16 | # Fortran module files 17 | *.mod 18 | 19 | # Compiled Static libraries 20 | *.lai 21 | *.la 22 | *.a 23 | *.lib 24 | 25 | # Executables 26 | *.exe 27 | *.out 28 | *.app 29 | /cmake-build-debug/ 30 | /.idea/* 31 | .DS_Store 32 | *.suo 33 | *.db 34 | */.vs/* 35 | **/x64/* 36 | Release 37 | **/bin/* 38 | **/build-qt*/** 39 | **/qt.pro.* 40 | -------------------------------------------------------------------------------- /include/blib/bun/bun.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "impl/kv.hpp" 3 | #include "impl/orm.hpp" 4 | -------------------------------------------------------------------------------- /include/blib/bun/impl/endian.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | 5 | namespace bun { 6 | inline bool is_big_endian() { 7 | static const std::uint16_t val = 1; 8 | static const std::uint8_t* c = (std::uint8_t*)(&val); 9 | static const bool ret = *c ? false : true; 10 | return ret; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /include/blib/utils/Singleton.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | /////////////////////////////////////////////////////////////////////////////// 4 | /// @file Singleton.hpp 5 | /// @author BrainlessLabs 6 | /// @version 0.3 7 | /// @brief Helper class for creating a singleton. 8 | /////////////////////////////////////////////////////////////////////////////// 9 | 10 | #include 11 | 12 | namespace blib { 13 | ///////////////////////////////////////////////// 14 | /// @class Singleton 15 | /// @brief Helper class to create a singleton. 16 | /// @details Example usage: 17 | /// struct MakeMeSingleton : public ::blib::Singleton 18 | /// {}; 19 | ///////////////////////////////////////////////// 20 | template 21 | class Singleton : public boost::noncopyable { 22 | public: 23 | static T &i() { 24 | static T _me; 25 | return _me; 26 | } 27 | }; 28 | } -------------------------------------------------------------------------------- /include/blib/utils/debug.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // File created for debugging purpose -------------------------------------------------------------------------------- /include/third_party/hdr/sqlite_modern_cpp/extensions/boost_uuid.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace sqlite { 4 | // boost::uuid 5 | template<> database_binder&& operator <<( database_binder&& db, const boost::uuids::uuid&& uuid ) { 6 | 7 | auto ret = sqlite3_bind_blob( db._stmt, db._inx, uuid.begin(), uuid.size(), SQLITE_TRANSIENT ); 8 | if (ret != SQLITE_OK) { 9 | db.throw_sqlite_error( ret ); 10 | } 11 | 12 | ++db._inx; 13 | return std::move( db ); 14 | } 15 | template <> void get_col_from_db( database_binder& db, int inx, boost::uuids::uuid& uuid ) { 16 | if (sqlite3_column_type( db._stmt, inx ) == SQLITE_NULL) { 17 | uuid = boost::uuids::uuid(); 18 | } 19 | else { 20 | const auto bytes = uuid.size(); 21 | if (sqlite3_column_bytes( db._stmt, inx ) != bytes) { 22 | db.throw_custom_error( "UUID size does not match!" ); 23 | } 24 | memcpy( uuid.begin(), sqlite3_column_blob( db._stmt, inx ), bytes ); 25 | } 26 | } 27 | } -------------------------------------------------------------------------------- /include/third_party/hdr/sqlite_modern_cpp/extensions/std_time_t.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace sqlite { 4 | // std::time_t 5 | template inline void get_col_from_db( database_binder& db, int inx, std::time_t& t ) { 6 | if (sqlite3_column_type( db._stmt, inx ) == SQLITE_NULL) { 7 | t = 0; 8 | } 9 | else { 10 | t = sqlite3_column_int64( db._stmt, inx ); 11 | } 12 | } 13 | template inline database_binder&& operator <<( database_binder&& db, const std::time_t&& val ) { 14 | //sqlite_int64 tmpval = static_cast(val); 15 | auto ret = sqlite3_bind_int64( db._stmt, db._inx, val ); 16 | if (ret != SQLITE_OK) db.throw_sqlite_error( ret ); 17 | ++db._inx; 18 | return std::move( db ); 19 | } 20 | } -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack.h: -------------------------------------------------------------------------------- 1 | /* 2 | * MessagePack for C 3 | * 4 | * Copyright (C) 2008-2009 FURUHASHI Sadayuki 5 | * 6 | * Distributed under the Boost Software License, Version 1.0. 7 | * (See accompanying file LICENSE_1_0.txt or copy at 8 | * http://www.boost.org/LICENSE_1_0.txt) 9 | */ 10 | /** 11 | * @defgroup msgpack MessagePack C 12 | * @{ 13 | * @} 14 | */ 15 | 16 | #include "msgpack/util.h" 17 | #include "msgpack/object.h" 18 | #include "msgpack/zone.h" 19 | #include "msgpack/pack.h" 20 | #include "msgpack/unpack.h" 21 | #include "msgpack/sbuffer.h" 22 | #include "msgpack/vrefbuffer.h" 23 | #include "msgpack/version.h" 24 | 25 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ 3 | // 4 | // Copyright (C) 2008-2009 FURUHASHI Sadayuki 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #include "msgpack/object.hpp" 11 | #include "msgpack/iterator.hpp" 12 | #include "msgpack/zone.hpp" 13 | #include "msgpack/pack.hpp" 14 | #include "msgpack/unpack.hpp" 15 | #include "msgpack/sbuffer.hpp" 16 | #include "msgpack/vrefbuffer.hpp" 17 | #include "msgpack/version.hpp" 18 | #include "msgpack/type.hpp" 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/adaptor_base.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_ADAPTOR_BASE_HPP 11 | #define MSGPACK_ADAPTOR_BASE_HPP 12 | 13 | #include "msgpack/adaptor/adaptor_base_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/adaptor_base.hpp" 16 | #include "msgpack/v2/adaptor/adaptor_base.hpp" 17 | 18 | #endif // MSGPACK_ADAPTOR_BASE_HPP 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/adaptor_base_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_ADAPTOR_BASE_DECL_HPP 11 | #define MSGPACK_ADAPTOR_BASE_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/adaptor_base_decl.hpp" 14 | #include "msgpack/v2/adaptor/adaptor_base_decl.hpp" 15 | 16 | #endif // MSGPACK_ADAPTOR_BASE_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/array_ref.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_ARRAY_REF_HPP 11 | #define MSGPACK_TYPE_ARRAY_REF_HPP 12 | 13 | #include "msgpack/adaptor/array_ref_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/array_ref.hpp" 16 | 17 | #endif // MSGPACK_TYPE_ARRAY_REFL_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/array_ref_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_ARRAY_REF_DECL_HPP 11 | #define MSGPACK_TYPE_ARRAY_REF_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/array_ref_decl.hpp" 14 | #include "msgpack/v2/adaptor/array_ref_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_ARRAY_REF_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/bool.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_BOOL_HPP 11 | #define MSGPACK_TYPE_BOOL_HPP 12 | 13 | #include "msgpack/v1/adaptor/bool.hpp" 14 | 15 | #endif // MSGPACK_TYPE_BOOL_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/boost/fusion.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_BOOST_FUSION_HPP 11 | #define MSGPACK_TYPE_BOOST_FUSION_HPP 12 | 13 | #include "msgpack/v1/adaptor/boost/fusion.hpp" 14 | 15 | #endif // MSGPACK_TYPE_BOOST_FUSION_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/boost/msgpack_variant.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP 11 | #define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP 12 | 13 | #include "msgpack/adaptor/boost/msgpack_variant_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/boost/msgpack_variant.hpp" 16 | //#include "msgpack/v2/adaptor/boost/msgpack_variant.hpp" 17 | 18 | #endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_HPP 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/boost/msgpack_variant_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP 11 | #define MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp" 14 | #include "msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/boost/optional.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_BOOST_OPTIONAL_HPP 11 | #define MSGPACK_TYPE_BOOST_OPTIONAL_HPP 12 | 13 | #include "msgpack/v1/adaptor/boost/optional.hpp" 14 | 15 | #endif // MSGPACK_TYPE_BOOST_OPTIONAL_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/boost/string_ref.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_BOOST_STRING_REF_HPP 11 | #define MSGPACK_TYPE_BOOST_STRING_REF_HPP 12 | 13 | #include "msgpack/v1/adaptor/boost/string_ref.hpp" 14 | 15 | #endif // MSGPACK_TYPE_BOOST_STRING_REF_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/boost/string_view.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2017 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_BOOST_STRING_VIEW_HPP 11 | #define MSGPACK_TYPE_BOOST_STRING_VIEW_HPP 12 | 13 | #include "msgpack/v1/adaptor/boost/string_view.hpp" 14 | 15 | #endif // MSGPACK_TYPE_BOOST_STRING_VIEW_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/carray.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_CARRAY_HPP 11 | #define MSGPACK_TYPE_CARRAY_HPP 12 | 13 | #include "msgpack/v1/adaptor/carray.hpp" 14 | 15 | #endif // MSGPACK_TYPE_CARRAY_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/char_ptr.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_CHAR_PTR_HPP 11 | #define MSGPACK_TYPE_CHAR_PTR_HPP 12 | 13 | #include "msgpack/v1/adaptor/char_ptr.hpp" 14 | 15 | #endif // MSGPACK_TYPE_CHAR_PTR_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/check_container_size.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_CHECK_CONTAINER_SIZE_HPP 11 | #define MSGPACK_CHECK_CONTAINER_SIZE_HPP 12 | 13 | #include "msgpack/adaptor/check_container_size_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/check_container_size.hpp" 16 | 17 | #endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/check_container_size_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP 11 | #define MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/check_container_size_decl.hpp" 14 | #include "msgpack/v2/adaptor/check_container_size_decl.hpp" 15 | 16 | #endif // MSGPACK_CHECK_CONTAINER_SIZE_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/array.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_ARRAY_HPP 12 | #define MSGPACK_TYPE_CPP11_ARRAY_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/array.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_ARRAY_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/array_char.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP 12 | #define MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/array_char.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_ARRAY_CHAR_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/array_unsigned_char.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP 12 | #define MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/array_unsigned_char.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_ARRAY_UNSIGNED_CHAR_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/forward_list.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP 12 | #define MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/forward_list.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_FORWARD_LIST_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/reference_wrapper.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP 12 | #define MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/reference_wrapper.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_REFERENCE_WRAPPER_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/shared_ptr.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_SHARED_PTR_HPP 12 | #define MSGPACK_TYPE_CPP11_SHARED_PTR_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/shared_ptr.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_SHARED_PTR_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/tuple.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_TUPLE_HPP 12 | #define MSGPACK_TYPE_CPP11_TUPLE_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/tuple.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_TUPLE_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/unique_ptr.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP 12 | #define MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/unique_ptr.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_UNIQUE_PTR_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/unordered_map.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP 12 | #define MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/unordered_map.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_UNORDERED_MAP_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp11/unordered_set.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP 12 | #define MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp11/unordered_set.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP11_UNORDERED_SET_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp17/optional.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2017 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP17_OPTIONAL_HPP 12 | #define MSGPACK_TYPE_CPP17_OPTIONAL_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp17/optional.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP17_OPTIONAL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/cpp17/string_view.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2017 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_TYPE_CPP17_STRING_VIEW_HPP 12 | #define MSGPACK_TYPE_CPP17_STRING_VIEW_HPP 13 | 14 | #include "msgpack/v1/adaptor/cpp17/string_view.hpp" 15 | 16 | #endif // MSGPACK_TYPE_CPP17_STRING_VIEW_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/define.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_DEFINE_HPP 11 | #define MSGPACK_DEFINE_HPP 12 | 13 | #include "msgpack/adaptor/define_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/define.hpp" 16 | 17 | #endif // MSGPACK_DEFINE_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/deque.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_DEQUE_HPP 11 | #define MSGPACK_TYPE_DEQUE_HPP 12 | 13 | #include "msgpack/v1/adaptor/deque.hpp" 14 | 15 | #endif // MSGPACK_TYPE_DEQUE_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/ext.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_EXT_HPP 11 | #define MSGPACK_TYPE_EXT_HPP 12 | 13 | #include "msgpack/adaptor/ext_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/ext.hpp" 16 | 17 | #endif // MSGPACK_TYPE_EXT_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/ext_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_EXT_DECL_HPP 11 | #define MSGPACK_TYPE_EXT_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/ext_decl.hpp" 14 | #include "msgpack/v2/adaptor/ext_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_EXT_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/fixint.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_FIXINT_HPP 11 | #define MSGPACK_TYPE_FIXINT_HPP 12 | 13 | #include "msgpack/adaptor/fixint_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/fixint.hpp" 16 | 17 | #endif // MSGPACK_TYPE_FIXINT_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/fixint_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_FIXINT_DECL_HPP 11 | #define MSGPACK_TYPE_FIXINT_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/fixint_decl.hpp" 14 | #include "msgpack/v2/adaptor/fixint_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_FIXINT_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/float.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_FLOAT_HPP 11 | #define MSGPACK_TYPE_FLOAT_HPP 12 | 13 | #include "msgpack/v1/adaptor/float.hpp" 14 | 15 | #endif // MSGPACK_TYPE_FLOAT_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/int.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_INT_HPP 11 | #define MSGPACK_TYPE_INT_HPP 12 | 13 | #include "msgpack/adaptor/int_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/int.hpp" 16 | 17 | #endif // MSGPACK_TYPE_INT_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/int_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_INT_DECL_HPP 11 | #define MSGPACK_TYPE_INT_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/int_decl.hpp" 14 | #include "msgpack/v2/adaptor/int_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_INT_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/list.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_LIST_HPP 11 | #define MSGPACK_TYPE_LIST_HPP 12 | 13 | #include "msgpack/v1/adaptor/list.hpp" 14 | 15 | #endif // MSGPACK_TYPE_LIST_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/map.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_MAP_HPP 11 | #define MSGPACK_TYPE_MAP_HPP 12 | 13 | #include "msgpack/adaptor/map_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/map.hpp" 16 | 17 | 18 | #endif // MSGPACK_TYPE_MAP_HPP 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/map_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_MAP_DECL_HPP 11 | #define MSGPACK_TYPE_MAP_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/map_decl.hpp" 14 | #include "msgpack/v2/adaptor/map_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_MAP_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/msgpack_tuple.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_MSGPACK_TUPLE_HPP 11 | #define MSGPACK_MSGPACK_TUPLE_HPP 12 | 13 | #include "msgpack/adaptor/msgpack_tuple_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/msgpack_tuple.hpp" 16 | 17 | #endif // MSGPACK_MSGPACK_TUPLE_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/msgpack_tuple_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_MSGPACK_TUPLE_DECL_HPP 11 | #define MSGPACK_MSGPACK_TUPLE_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/msgpack_tuple_decl.hpp" 14 | #include "msgpack/v2/adaptor/msgpack_tuple_decl.hpp" 15 | 16 | #endif // MSGPACK_MSGPACK_TUPLE_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/nil.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_NIL_HPP 11 | #define MSGPACK_TYPE_NIL_HPP 12 | 13 | #include "msgpack/adaptor/nil_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/nil.hpp" 16 | 17 | #endif // MSGPACK_TYPE_NIL_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/nil_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_NIL_DECL_HPP 11 | #define MSGPACK_TYPE_NIL_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/nil_decl.hpp" 14 | #include "msgpack/v2/adaptor/nil_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_NIL_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/pair.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_PAIR_HPP 11 | #define MSGPACK_TYPE_PAIR_HPP 12 | 13 | #include "msgpack/v1/adaptor/pair.hpp" 14 | 15 | #endif // MSGPACK_TYPE_PAIR_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/raw.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_RAW_HPP 11 | #define MSGPACK_TYPE_RAW_HPP 12 | 13 | #include "msgpack/adaptor/raw_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/raw.hpp" 16 | 17 | #endif // MSGPACK_TYPE_RAW_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/raw_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_RAW_DECL_HPP 11 | #define MSGPACK_TYPE_RAW_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/raw_decl.hpp" 14 | #include "msgpack/v2/adaptor/raw_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_RAW_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/set.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_SET_HPP 11 | #define MSGPACK_TYPE_SET_HPP 12 | 13 | #include "msgpack/v1/adaptor/set.hpp" 14 | 15 | #endif // MSGPACK_TYPE_SET_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/size_equal_only.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_SIZE_EQUAL_ONLY_HPP 11 | #define MSGPACK_TYPE_SIZE_EQUAL_ONLY_HPP 12 | 13 | #include "msgpack/adaptor/size_equal_only_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/size_equal_only.hpp" 16 | 17 | #endif // MSGPACK_TYPE_SIZE_EQUAL_ONLYL_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/size_equal_only_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_SIZE_EQUAL_ONLY_DECL_HPP 11 | #define MSGPACK_TYPE_SIZE_EQUAL_ONLY_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/size_equal_only_decl.hpp" 14 | #include "msgpack/v2/adaptor/size_equal_only_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_SIZE_EQUAL_ONLY_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/string.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_STRING_HPP 11 | #define MSGPACK_TYPE_STRING_HPP 12 | 13 | #include "msgpack/v1/adaptor/string.hpp" 14 | 15 | #endif // MSGPACK_TYPE_STRING_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/v4raw.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_V4RAW_HPP 11 | #define MSGPACK_TYPE_V4RAW_HPP 12 | 13 | #include "msgpack/adaptor/v4raw_decl.hpp" 14 | 15 | #include "msgpack/v1/adaptor/v4raw.hpp" 16 | 17 | #endif // MSGPACK_TYPE_V4RAW_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/v4raw_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_V4RAW_DECL_HPP 11 | #define MSGPACK_TYPE_V4RAW_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/v4raw_decl.hpp" 14 | #include "msgpack/v2/adaptor/v4raw_decl.hpp" 15 | 16 | #endif // MSGPACK_TYPE_V4RAW_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/vector.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_VECTOR_HPP 11 | #define MSGPACK_TYPE_VECTOR_HPP 12 | 13 | #include "msgpack/v1/adaptor/vector.hpp" 14 | 15 | #endif // MSGPACK_TYPE_VECTOR_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/vector_bool.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_VECTOR_BOOL_HPP 11 | #define MSGPACK_TYPE_VECTOR_BOOL_HPP 12 | 13 | #include "msgpack/v1/adaptor/vector_bool.hpp" 14 | 15 | #endif // MSGPACK_TYPE_VECTOR_BOOL_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/vector_char.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_VECTOR_CHAR_HPP 11 | #define MSGPACK_TYPE_VECTOR_CHAR_HPP 12 | 13 | #include "msgpack/v1/adaptor/vector_char.hpp" 14 | 15 | #endif // MSGPACK_TYPE_VECTOR_CHAR_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/adaptor/vector_unsigned_char.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP 11 | #define MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP 12 | 13 | #include "msgpack/v1/adaptor/vector_unsigned_char.hpp" 14 | 15 | #endif // MSGPACK_TYPE_VECTOR_UNSIGNED_CHAR_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/cpp_config.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ C++03/C++11 Adaptation 3 | // 4 | // Copyright (C) 2013-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_CPP_CONFIG_HPP 11 | #define MSGPACK_CPP_CONFIG_HPP 12 | 13 | #include "msgpack/cpp_config_decl.hpp" 14 | 15 | #include "msgpack/v1/cpp_config.hpp" 16 | 17 | #endif // MSGPACK_CPP_CONFIG_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/cpp_config_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ C++03/C++11 Adaptation 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_CPP_CONFIG_DECL_HPP 11 | #define MSGPACK_CPP_CONFIG_DECL_HPP 12 | 13 | #include "msgpack/v1/cpp_config_decl.hpp" 14 | #include "msgpack/v2/cpp_config_decl.hpp" 15 | 16 | #endif // MSGPACK_CPP_CONFIG_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/fbuffer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * MessagePack for C FILE* buffer adaptor 3 | * 4 | * Copyright (C) 2013 Vladimir Volodko 5 | * 6 | * Distributed under the Boost Software License, Version 1.0. 7 | * (See accompanying file LICENSE_1_0.txt or copy at 8 | * http://www.boost.org/LICENSE_1_0.txt) 9 | */ 10 | #ifndef MSGPACK_FBUFFER_H 11 | #define MSGPACK_FBUFFER_H 12 | 13 | #include 14 | 15 | #ifdef __cplusplus 16 | extern "C" { 17 | #endif 18 | 19 | 20 | /** 21 | * @defgroup msgpack_fbuffer FILE* buffer 22 | * @ingroup msgpack_buffer 23 | * @{ 24 | */ 25 | 26 | static inline int msgpack_fbuffer_write(void* data, const char* buf, size_t len) 27 | { 28 | return (len == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1; 29 | } 30 | 31 | /** @} */ 32 | 33 | 34 | #ifdef __cplusplus 35 | } 36 | #endif 37 | 38 | #endif /* msgpack/fbuffer.h */ 39 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/fbuffer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ FILE* buffer adaptor 3 | // 4 | // Copyright (C) 2013 Vladimir Volodko 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_FBUFFER_HPP 11 | #define MSGPACK_FBUFFER_HPP 12 | 13 | #include "msgpack/fbuffer_decl.hpp" 14 | 15 | #include "msgpack/v1/fbuffer.hpp" 16 | 17 | #endif // MSGPACK_FBUFFER_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/fbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ FILE* buffer adaptor 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_FBUFFER_DECL_HPP 11 | #define MSGPACK_FBUFFER_DECL_HPP 12 | 13 | #include "msgpack/v1/fbuffer_decl.hpp" 14 | #include "msgpack/v2/fbuffer_decl.hpp" 15 | 16 | #endif // MSGPACK_FBUFFER_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/gcc_atomic.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Distributed under the Boost Software License, Version 1.0. 3 | * (See accompanying file LICENSE_1_0.txt or copy at 4 | * http://www.boost.org/LICENSE_1_0.txt) 5 | */ 6 | 7 | #ifndef MSGPACK_GCC_ATOMIC_H 8 | #define MSGPACK_GCC_ATOMIC_H 9 | 10 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | typedef int _msgpack_atomic_counter_t; 15 | 16 | int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); 17 | int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); 18 | 19 | 20 | #if defined(__cplusplus) 21 | } 22 | #endif 23 | 24 | 25 | #endif // MSGPACK_GCC_ATOMIC_H 26 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/gcc_atomic.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ old gcc workaround for atomic operation 3 | // 4 | // Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_GCC_ATOMIC_HPP 12 | #define MSGPACK_GCC_ATOMIC_HPP 13 | 14 | #if defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) 15 | 16 | #include "msgpack/gcc_atomic.h" 17 | #include 18 | 19 | int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) 20 | { 21 | return __gnu_cxx::__exchange_and_add(ptr, -1) - 1; 22 | } 23 | 24 | int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) 25 | { 26 | return __gnu_cxx::__exchange_and_add(ptr, 1) + 1; 27 | } 28 | 29 | #endif // old gcc workaround 30 | 31 | #endif /* gcc_atomic.hpp */ 32 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/iterator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 MIZUKI Hirata 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_ITERATOR_HPP 12 | #define MSGPACK_ITERATOR_HPP 13 | 14 | #include 15 | 16 | #include 17 | 18 | #endif // MSGPACK_ITERATOR_HPP 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/iterator_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_ITERATOR_DECL_HPP 12 | #define MSGPACK_ITERATOR_DECL_HPP 13 | 14 | #include 15 | #include 16 | 17 | #endif // MSGPACK_V1_ITERATOR_DECL_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/meta.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_META_HPP 12 | #define MSGPACK_META_HPP 13 | 14 | #include "msgpack/meta_decl.hpp" 15 | 16 | #include "msgpack/v1/meta.hpp" 17 | 18 | #endif // MSGPACK_META_HPP 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/meta_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_META_DECL_HPP 12 | #define MSGPACK_META_DECL_HPP 13 | 14 | #include "msgpack/v1/meta_decl.hpp" 15 | #include "msgpack/v2/meta_decl.hpp" 16 | 17 | #endif // MSGPACK_META_DECL_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/object.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_OBJECT_HPP 11 | #define MSGPACK_OBJECT_HPP 12 | 13 | #include "msgpack/object_decl.hpp" 14 | 15 | #include "msgpack/v1/object.hpp" 16 | #include "msgpack/v2/object.hpp" 17 | 18 | #endif // MSGPACK_OBJECT_HPP 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/object_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_OBJECT_DECL_HPP 12 | #define MSGPACK_OBJECT_DECL_HPP 13 | 14 | #include "msgpack/v1/object_decl.hpp" 15 | #include "msgpack/v2/object_decl.hpp" 16 | 17 | #endif // MSGPACK_OBJECT_DECL_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/object_fwd.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_OBJECT_FWD_HPP 12 | #define MSGPACK_OBJECT_FWD_HPP 13 | 14 | #include "msgpack/object_fwd_decl.hpp" 15 | 16 | #include "msgpack/v1/object_fwd.hpp" 17 | #include "msgpack/v2/object_fwd.hpp" 18 | 19 | #endif // MSGPACK_OBJECT_FWD_HPP 20 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/object_fwd_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_OBJECT_FWD_DECL_HPP 12 | #define MSGPACK_OBJECT_FWD_DECL_HPP 13 | 14 | #include "msgpack/v1/object_fwd_decl.hpp" 15 | #include "msgpack/v2/object_fwd_decl.hpp" 16 | 17 | #endif // MSGPACK_OBJECT_FWD_DECL_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/pack.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ serializing routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_PACK_HPP 11 | #define MSGPACK_PACK_HPP 12 | 13 | #include "msgpack/pack_decl.hpp" 14 | 15 | #include "msgpack/v1/pack.hpp" 16 | 17 | #endif // MSGPACK_PACK_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/pack_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ serializing routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_PACK_DECL_HPP 11 | #define MSGPACK_PACK_DECL_HPP 12 | 13 | #include "msgpack/v1/pack_decl.hpp" 14 | #include "msgpack/v2/pack_decl.hpp" 15 | 16 | #endif // MSGPACK_PACK_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/pack_define.h: -------------------------------------------------------------------------------- 1 | /* 2 | * MessagePack unpacking routine template 3 | * 4 | * Copyright (C) 2008-2010 FURUHASHI Sadayuki 5 | * 6 | * Distributed under the Boost Software License, Version 1.0. 7 | * (See accompanying file LICENSE_1_0.txt or copy at 8 | * http://www.boost.org/LICENSE_1_0.txt) 9 | */ 10 | #ifndef MSGPACK_PACK_DEFINE_H 11 | #define MSGPACK_PACK_DEFINE_H 12 | 13 | #include "msgpack/sysdep.h" 14 | #include 15 | #include 16 | 17 | #endif /* msgpack/pack_define.h */ 18 | 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/parse_return.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deserializing routine 3 | // 4 | // Copyright (C) 2017 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_PARSE_RETURN_HPP 11 | #define MSGPACK_PARSE_RETURN_HPP 12 | 13 | #include "msgpack/v1/parse_return.hpp" 14 | #include "msgpack/v2/parse_return.hpp" 15 | 16 | #endif // MSGPACK_PARSE_RETURN_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #if !defined(MSGPACK_PREDEF_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 9 | #ifndef MSGPACK_PREDEF_H 10 | #define MSGPACK_PREDEF_H 11 | #endif 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | 22 | #include 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/architecture/pyramid.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2011-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_ARCHITECTURE_PYRAMID_H 9 | #define MSGPACK_PREDEF_ARCHITECTURE_PYRAMID_H 10 | 11 | #include 12 | #include 13 | 14 | /*` 15 | [heading `MSGPACK_ARCH_PYRAMID`] 16 | 17 | Pyramid 9810 architecture. 18 | 19 | [table 20 | [[__predef_symbol__] [__predef_version__]] 21 | 22 | [[`pyr`] [__predef_detection__]] 23 | ] 24 | */ 25 | 26 | #define MSGPACK_ARCH_PYRAMID MSGPACK_VERSION_NUMBER_NOT_AVAILABLE 27 | 28 | #if defined(pyr) 29 | # undef MSGPACK_ARCH_PYRAMID 30 | # define MSGPACK_ARCH_PYRAMID MSGPACK_VERSION_NUMBER_AVAILABLE 31 | #endif 32 | 33 | #if MSGPACK_ARCH_PYRAMID 34 | # define MSGPACK_ARCH_PYRAMID_AVAILABLE 35 | #endif 36 | 37 | #define MSGPACK_ARCH_PYRAMID_NAME "Pyramid 9810" 38 | 39 | #endif 40 | 41 | #include 42 | MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_PYRAMID,MSGPACK_ARCH_PYRAMID_NAME) 43 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/architecture/x86.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #include 9 | #include 10 | 11 | #ifndef MSGPACK_PREDEF_ARCHITECTURE_X86_H 12 | #define MSGPACK_PREDEF_ARCHITECTURE_X86_H 13 | 14 | /*` 15 | [heading `MSGPACK_ARCH_X86`] 16 | 17 | [@http://en.wikipedia.org/wiki/X86 Intel x86] architecture. This is 18 | a category to indicate that either `MSGPACK_ARCH_X86_32` or 19 | `MSGPACK_ARCH_X86_64` is detected. 20 | */ 21 | 22 | #define MSGPACK_ARCH_X86 MSGPACK_VERSION_NUMBER_NOT_AVAILABLE 23 | 24 | #if MSGPACK_ARCH_X86_32 || MSGPACK_ARCH_X86_64 25 | # undef MSGPACK_ARCH_X86 26 | # define MSGPACK_ARCH_X86 MSGPACK_VERSION_NUMBER_AVAILABLE 27 | #endif 28 | 29 | #if MSGPACK_ARCH_X86 30 | # define MSGPACK_ARCH_X86_AVAILABLE 31 | #endif 32 | 33 | #define MSGPACK_ARCH_X86_NAME "Intel x86" 34 | 35 | #endif 36 | 37 | #include 38 | MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_X86,MSGPACK_ARCH_X86_NAME) 39 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/architecture/z.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_ARCHITECTURE_Z_H 9 | #define MSGPACK_PREDEF_ARCHITECTURE_Z_H 10 | 11 | #include 12 | #include 13 | 14 | /*` 15 | [heading `MSGPACK_ARCH_Z`] 16 | 17 | [@http://en.wikipedia.org/wiki/Z/Architecture z/Architecture] architecture. 18 | 19 | [table 20 | [[__predef_symbol__] [__predef_version__]] 21 | 22 | [[`__SYSC_ZARCH__`] [__predef_detection__]] 23 | ] 24 | */ 25 | 26 | #define MSGPACK_ARCH_Z MSGPACK_VERSION_NUMBER_NOT_AVAILABLE 27 | 28 | #if defined(__SYSC_ZARCH__) 29 | # undef MSGPACK_ARCH_Z 30 | # define MSGPACK_ARCH_Z MSGPACK_VERSION_NUMBER_AVAILABLE 31 | #endif 32 | 33 | #if MSGPACK_ARCH_Z 34 | # define MSGPACK_ARCH_Z_AVAILABLE 35 | #endif 36 | 37 | #define MSGPACK_ARCH_Z_NAME "z/Architecture" 38 | 39 | #endif 40 | 41 | #include 42 | MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_ARCH_Z,MSGPACK_ARCH_Z_NAME) 43 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/detail/_cassert.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2011-2012 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_DETAIL__CASSERT_H 9 | #define MSGPACK_PREDEF_DETAIL__CASSERT_H 10 | 11 | #if defined(__cplusplus) 12 | #include 13 | #else 14 | #include 15 | #endif 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/detail/_exception.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2011-2012 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_DETAIL__EXCEPTION_H 9 | #define MSGPACK_PREDEF_DETAIL__EXCEPTION_H 10 | 11 | #if defined(__cplusplus) 12 | #include 13 | #endif 14 | 15 | #endif 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/detail/comp_detected.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2014 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_DETAIL_COMP_DETECTED 9 | #define MSGPACK_PREDEF_DETAIL_COMP_DETECTED 1 10 | #endif 11 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/detail/endian_compat.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2013 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_DETAIL_ENDIAN_COMPAT_H 9 | #define MSGPACK_PREDEF_DETAIL_ENDIAN_COMPAT_H 10 | 11 | #include 12 | 13 | #if MSGPACK_ENDIAN_BIG_BYTE 14 | # define MSGPACK_BIG_ENDIAN 15 | # define MSGPACK_BYTE_ORDER 4321 16 | #endif 17 | #if MSGPACK_ENDIAN_LITTLE_BYTE 18 | # define MSGPACK_LITTLE_ENDIAN 19 | # define MSGPACK_BYTE_ORDER 1234 20 | #endif 21 | #if MSGPACK_ENDIAN_LITTLE_WORD 22 | # define MSGPACK_PDP_ENDIAN 23 | # define MSGPACK_BYTE_ORDER 2134 24 | #endif 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/detail/os_detected.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2013 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_DETAIL_OS_DETECTED 9 | #define MSGPACK_PREDEF_DETAIL_OS_DETECTED 1 10 | #endif 11 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/detail/platform_detected.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2014 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_DETAIL_PLAT_DETECTED 9 | #define MSGPACK_PREDEF_DETAIL_PLAT_DETECTED 1 10 | #endif 11 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/detail/test.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2011-2012 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_DETAIL_TEST_H 9 | #define MSGPACK_PREDEF_DETAIL_TEST_H 10 | 11 | #if !defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 12 | 13 | #define MSGPACK_PREDEF_DECLARE_TEST(x,s) 14 | 15 | #endif 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/hardware.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Charly Chevalier 2015 3 | Copyright Joel Falcou 2015 4 | Distributed under the Boost Software License, Version 1.0. 5 | (See accompanying file LICENSE_1_0.txt or copy at 6 | http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #if !defined(MSGPACK_PREDEF_HARDWARE_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 10 | #ifndef MSGPACK_PREDEF_HARDWARE_H 11 | #define MSGPACK_PREDEF_HARDWARE_H 12 | #endif 13 | 14 | #include 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/hardware/simd/arm/versions.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Charly Chevalier 2015 3 | Copyright Joel Falcou 2015 4 | Distributed under the Boost Software License, Version 1.0. 5 | (See accompanying file LICENSE_1_0.txt or copy at 6 | http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #ifndef MSGPACK_PREDEF_HARDWARE_SIMD_ARM_VERSIONS_H 10 | #define MSGPACK_PREDEF_HARDWARE_SIMD_ARM_VERSIONS_H 11 | 12 | #include 13 | 14 | /*` 15 | Those defines represent ARM SIMD extensions versions. 16 | 17 | [note You *MUST* compare them with the predef `MSGPACK_HW_SIMD_ARM`.] 18 | */ 19 | 20 | // --------------------------------- 21 | 22 | /*` 23 | [heading `MSGPACK_HW_SIMD_ARM_NEON_VERSION`] 24 | 25 | The [@https://en.wikipedia.org/wiki/ARM_architecture#Advanced_SIMD_.28NEON.29 NEON] 26 | ARM extension version number. 27 | 28 | Version number is: *1.0.0*. 29 | */ 30 | #define MSGPACK_HW_SIMD_ARM_NEON_VERSION MSGPACK_VERSION_NUMBER(1, 0, 0) 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/language.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2011-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #if !defined(MSGPACK_PREDEF_LANGUAGE_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 9 | #ifndef MSGPACK_PREDEF_LANGUAGE_H 10 | #define MSGPACK_PREDEF_LANGUAGE_H 11 | #endif 12 | 13 | #include 14 | #include 15 | #include 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/language/objc.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2011-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_LANGUAGE_OBJC_H 9 | #define MSGPACK_PREDEF_LANGUAGE_OBJC_H 10 | 11 | #include 12 | #include 13 | 14 | /*` 15 | [heading `MSGPACK_LANG_OBJC`] 16 | 17 | [@http://en.wikipedia.org/wiki/Objective-C Objective-C] language. 18 | 19 | [table 20 | [[__predef_symbol__] [__predef_version__]] 21 | 22 | [[`__OBJC__`] [__predef_detection__]] 23 | ] 24 | */ 25 | 26 | #define MSGPACK_LANG_OBJC MSGPACK_VERSION_NUMBER_NOT_AVAILABLE 27 | 28 | #if defined(__OBJC__) 29 | # undef MSGPACK_LANG_OBJC 30 | # define MSGPACK_LANG_OBJC MSGPACK_VERSION_NUMBER_AVAILABLE 31 | #endif 32 | 33 | #if MSGPACK_LANG_OBJC 34 | # define MSGPACK_LANG_OBJC_AVAILABLE 35 | #endif 36 | 37 | #define MSGPACK_LANG_OBJC_NAME "Objective-C" 38 | 39 | #endif 40 | 41 | #include 42 | MSGPACK_PREDEF_DECLARE_TEST(MSGPACK_LANG_OBJC,MSGPACK_LANG_OBJC_NAME) 43 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/library.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #if !defined(MSGPACK_PREDEF_LIBRARY_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 9 | #ifndef MSGPACK_PREDEF_LIBRARY_H 10 | #define MSGPACK_PREDEF_LIBRARY_H 11 | #endif 12 | 13 | #include 14 | #include 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/library/c.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #if !defined(MSGPACK_PREDEF_LIBRARY_C_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 9 | #ifndef MSGPACK_PREDEF_LIBRARY_C_H 10 | #define MSGPACK_PREDEF_LIBRARY_C_H 11 | #endif 12 | 13 | #include 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/library/c/_prefix.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2013 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_LIBRARY_C__PREFIX_H 9 | #define MSGPACK_PREDEF_LIBRARY_C__PREFIX_H 10 | 11 | #include 12 | 13 | #endif 14 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/library/std.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | #if !defined(MSGPACK_PREDEF_LIBRARY_STD_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 8 | #ifndef MSGPACK_PREDEF_LIBRARY_STD_H 9 | #define MSGPACK_PREDEF_LIBRARY_STD_H 10 | #endif 11 | 12 | #include 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/library/std/_prefix.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2013 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | #ifndef MSGPACK_PREDEF_LIBRARY_STD__PREFIX_H 8 | #define MSGPACK_PREDEF_LIBRARY_STD__PREFIX_H 9 | 10 | /* 11 | We need to include an STD header to gives us the context 12 | of which library we are using. The "smallest" code-wise header 13 | seems to be . Boost uses but as far 14 | as I can tell (RR) it's not a stand-alone header in most 15 | implementations. Using also has the benefit of 16 | being available in EC++, so we get a chance to make this work 17 | for embedded users. And since it's not a header impacted by TR1 18 | there's no magic needed for inclusion in the face of the 19 | Boost.TR1 library. 20 | */ 21 | #include 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/os.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2008-2015 3 | Copyright Franz Detro 2014 4 | Distributed under the Boost Software License, Version 1.0. 5 | (See accompanying file LICENSE_1_0.txt or copy at 6 | http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #if !defined(MSGPACK_PREDEF_OS_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 10 | #ifndef MSGPACK_PREDEF_OS_H 11 | #define MSGPACK_PREDEF_OS_H 12 | #endif 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/other.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2013-2015 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #if !defined(MSGPACK_PREDEF_OTHER_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 9 | #ifndef MSGPACK_PREDEF_OTHER_H 10 | #define MSGPACK_PREDEF_OTHER_H 11 | #endif 12 | 13 | #include 14 | /*#include */ 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/platform.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2013-2015 3 | Copyright (c) Microsoft Corporation 2014 4 | Distributed under the Boost Software License, Version 1.0. 5 | (See accompanying file LICENSE_1_0.txt or copy at 6 | http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #if !defined(MSGPACK_PREDEF_PLATFORM_H) || defined(MSGPACK_PREDEF_INTERNAL_GENERATE_TESTS) 10 | #ifndef MSGPACK_PREDEF_PLATFORM_H 11 | #define MSGPACK_PREDEF_PLATFORM_H 12 | #endif 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | /*#include */ 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/predef/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright Rene Rivera 2015-2016 3 | Distributed under the Boost Software License, Version 1.0. 4 | (See accompanying file LICENSE_1_0.txt or copy at 5 | http://www.boost.org/LICENSE_1_0.txt) 6 | */ 7 | 8 | #ifndef MSGPACK_PREDEF_VERSION_H 9 | #define MSGPACK_PREDEF_VERSION_H 10 | 11 | #include 12 | 13 | #define MSGPACK_PREDEF_VERSION MSGPACK_VERSION_NUMBER(1,4,1) 14 | 15 | #endif 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org/libs/preprocessor for documentation. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_HPP 15 | # define MSGPACK_PREPROCESSOR_HPP 16 | # 17 | # include 18 | # 19 | # endif 20 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/arithmetic.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_ARITHMETIC_HPP 15 | # define MSGPACK_PREPROCESSOR_ARITHMETIC_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # include 21 | # include 22 | # include 23 | # include 24 | # 25 | # endif 26 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/assert_msg.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ASSERT_MSG_HPP 13 | # define MSGPACK_PREPROCESSOR_ASSERT_MSG_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/cat.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_CAT_HPP 15 | # define MSGPACK_PREPROCESSOR_CAT_HPP 16 | # 17 | # include 18 | # 19 | # /* MSGPACK_PP_CAT */ 20 | # 21 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_MWCC() 22 | # define MSGPACK_PP_CAT(a, b) MSGPACK_PP_CAT_I(a, b) 23 | # else 24 | # define MSGPACK_PP_CAT(a, b) MSGPACK_PP_CAT_OO((a, b)) 25 | # define MSGPACK_PP_CAT_OO(par) MSGPACK_PP_CAT_I ## par 26 | # endif 27 | # 28 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_MSVC() 29 | # define MSGPACK_PP_CAT_I(a, b) a ## b 30 | # else 31 | # define MSGPACK_PP_CAT_I(a, b) MSGPACK_PP_CAT_II(~, a ## b) 32 | # define MSGPACK_PP_CAT_II(p, res) res 33 | # endif 34 | # 35 | # endif 36 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/comma.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_COMMA_HPP 13 | # define MSGPACK_PREPROCESSOR_COMMA_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/comma_if.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_COMMA_IF_HPP 13 | # define MSGPACK_PREPROCESSOR_COMMA_IF_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/comparison.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_COMPARISON_HPP 15 | # define MSGPACK_PREPROCESSOR_COMPARISON_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # include 21 | # include 22 | # include 23 | # 24 | # endif 25 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/config/limits.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # /* Revised by Edward Diener (2011) */ 12 | # 13 | # /* See http://www.boost.org for most recent version. */ 14 | # 15 | # ifndef MSGPACK_PREPROCESSOR_CONFIG_LIMITS_HPP 16 | # define MSGPACK_PREPROCESSOR_CONFIG_LIMITS_HPP 17 | # 18 | # define MSGPACK_PP_LIMIT_MAG 256 19 | # define MSGPACK_PP_LIMIT_TUPLE 64 20 | # define MSGPACK_PP_LIMIT_DIM 3 21 | # define MSGPACK_PP_LIMIT_REPEAT 256 22 | # define MSGPACK_PP_LIMIT_WHILE 256 23 | # define MSGPACK_PP_LIMIT_FOR 256 24 | # define MSGPACK_PP_LIMIT_ITERATION 256 25 | # define MSGPACK_PP_LIMIT_ITERATION_DIM 3 26 | # define MSGPACK_PP_LIMIT_SEQ 256 27 | # define MSGPACK_PP_LIMIT_SLOT_SIG 10 28 | # define MSGPACK_PP_LIMIT_SLOT_COUNT 5 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/control.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_CONTROL_HPP 13 | # define MSGPACK_PREPROCESSOR_CONTROL_HPP 14 | # 15 | # include 16 | # include 17 | # include 18 | # include 19 | # include 20 | # include 21 | # 22 | # endif 23 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/control/deduce_d.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_CONTROL_DEDUCE_D_HPP 13 | # define MSGPACK_PREPROCESSOR_CONTROL_DEDUCE_D_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* MSGPACK_PP_DEDUCE_D */ 19 | # 20 | # define MSGPACK_PP_DEDUCE_D() MSGPACK_PP_AUTO_REC(MSGPACK_PP_WHILE_P, 256) 21 | # 22 | # endif 23 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/control/expr_if.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_CONTROL_EXPR_IF_HPP 15 | # define MSGPACK_PREPROCESSOR_CONTROL_EXPR_IF_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_EXPR_IF */ 22 | # 23 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG() 24 | # define MSGPACK_PP_EXPR_IF(cond, expr) MSGPACK_PP_EXPR_IIF(MSGPACK_PP_BOOL(cond), expr) 25 | # else 26 | # define MSGPACK_PP_EXPR_IF(cond, expr) MSGPACK_PP_EXPR_IF_I(cond, expr) 27 | # define MSGPACK_PP_EXPR_IF_I(cond, expr) MSGPACK_PP_EXPR_IIF(MSGPACK_PP_BOOL(cond), expr) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/control/if.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_CONTROL_IF_HPP 15 | # define MSGPACK_PREPROCESSOR_CONTROL_IF_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_IF */ 22 | # 23 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG() 24 | # define MSGPACK_PP_IF(cond, t, f) MSGPACK_PP_IIF(MSGPACK_PP_BOOL(cond), t, f) 25 | # else 26 | # define MSGPACK_PP_IF(cond, t, f) MSGPACK_PP_IF_I(cond, t, f) 27 | # define MSGPACK_PP_IF_I(cond, t, f) MSGPACK_PP_IIF(MSGPACK_PP_BOOL(cond), t, f) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/debug.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_DEBUG_HPP 13 | # define MSGPACK_PREPROCESSOR_DEBUG_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # endif 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/dec.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_DEC_HPP 13 | # define MSGPACK_PREPROCESSOR_DEC_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/detail/null.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_DETAIL_NULL_HPP 13 | # define MSGPACK_PREPROCESSOR_DETAIL_NULL_HPP 14 | # 15 | # /* empty file */ 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/empty.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_EMPTY_HPP 13 | # define MSGPACK_PREPROCESSOR_EMPTY_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/enum.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ENUM_HPP 13 | # define MSGPACK_PREPROCESSOR_ENUM_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/enum_params.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ENUM_PARAMS_HPP 13 | # define MSGPACK_PREPROCESSOR_ENUM_PARAMS_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/enum_params_with_a_default.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ENUM_PARAMS_WITH_A_DEFAULT_HPP 13 | # define MSGPACK_PREPROCESSOR_ENUM_PARAMS_WITH_A_DEFAULT_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/enum_params_with_defaults.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ENUM_PARAMS_WITH_DEFAULTS_HPP 13 | # define MSGPACK_PREPROCESSOR_ENUM_PARAMS_WITH_DEFAULTS_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/enum_shifted.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ENUM_SHIFTED_HPP 13 | # define MSGPACK_PREPROCESSOR_ENUM_SHIFTED_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/enum_shifted_params.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ENUM_SHIFTED_PARAMS_HPP 13 | # define MSGPACK_PREPROCESSOR_ENUM_SHIFTED_PARAMS_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/expand.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_EXPAND_HPP 13 | # define MSGPACK_PREPROCESSOR_EXPAND_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/expr_if.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_EXPR_IF_HPP 13 | # define MSGPACK_PREPROCESSOR_EXPR_IF_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/facilities/empty.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_FACILITIES_EMPTY_HPP 15 | # define MSGPACK_PREPROCESSOR_FACILITIES_EMPTY_HPP 16 | # 17 | # include 18 | # 19 | # /* MSGPACK_PP_EMPTY */ 20 | # 21 | # define MSGPACK_PP_EMPTY() 22 | # 23 | # endif 24 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/facilities/expand.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_FACILITIES_EXPAND_HPP 15 | # define MSGPACK_PREPROCESSOR_FACILITIES_EXPAND_HPP 16 | # 17 | # include 18 | # 19 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_MWCC() && ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_DMC() 20 | # define MSGPACK_PP_EXPAND(x) MSGPACK_PP_EXPAND_I(x) 21 | # else 22 | # define MSGPACK_PP_EXPAND(x) MSGPACK_PP_EXPAND_OO((x)) 23 | # define MSGPACK_PP_EXPAND_OO(par) MSGPACK_PP_EXPAND_I ## par 24 | # endif 25 | # 26 | # define MSGPACK_PP_EXPAND_I(x) x 27 | # 28 | # endif 29 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/facilities/identity.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # /* Revised by Edward Diener (2015) */ 12 | # 13 | # /* See http://www.boost.org for most recent version. */ 14 | # 15 | # ifndef MSGPACK_PREPROCESSOR_FACILITIES_IDENTITY_HPP 16 | # define MSGPACK_PREPROCESSOR_FACILITIES_IDENTITY_HPP 17 | # 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_IDENTITY */ 22 | # 23 | # define MSGPACK_PP_IDENTITY(item) item MSGPACK_PP_EMPTY 24 | # 25 | # define MSGPACK_PP_IDENTITY_N(item,n) item MSGPACK_PP_TUPLE_EAT_N(n) 26 | # 27 | # endif 28 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/facilities/is_1.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2003. 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_FACILITIES_IS_1_HPP 13 | # define MSGPACK_PREPROCESSOR_FACILITIES_IS_1_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* MSGPACK_PP_IS_1 */ 19 | # 20 | # define MSGPACK_PP_IS_1(x) MSGPACK_PP_IS_EMPTY(MSGPACK_PP_CAT(MSGPACK_PP_IS_1_HELPER_, x)) 21 | # define MSGPACK_PP_IS_1_HELPER_1 22 | # 23 | # endif 24 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/for.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_FOR_HPP 13 | # define MSGPACK_PREPROCESSOR_FOR_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/identity.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_IDENTITY_HPP 13 | # define MSGPACK_PREPROCESSOR_IDENTITY_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/if.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_IF_HPP 13 | # define MSGPACK_PREPROCESSOR_IF_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/inc.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_INC_HPP 13 | # define MSGPACK_PREPROCESSOR_INC_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/iterate.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ITERATE_HPP 13 | # define MSGPACK_PREPROCESSOR_ITERATE_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/iteration.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ITERATION_HPP 13 | # define MSGPACK_PREPROCESSOR_ITERATION_HPP 14 | # 15 | # include 16 | # include 17 | # include 18 | # 19 | # endif 20 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/iteration/detail/self.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # if !defined(MSGPACK_PP_INDIRECT_SELF) 13 | # error MSGPACK_PP_ERROR: no indirect file to include 14 | # endif 15 | # 16 | # define MSGPACK_PP_IS_SELFISH 1 17 | # 18 | # include MSGPACK_PP_INDIRECT_SELF 19 | # 20 | # undef MSGPACK_PP_IS_SELFISH 21 | # undef MSGPACK_PP_INDIRECT_SELF 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/iteration/self.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_ITERATION_SELF_HPP 13 | # define MSGPACK_PREPROCESSOR_ITERATION_SELF_HPP 14 | # 15 | # /* MSGPACK_PP_INCLUDE_SELF */ 16 | # 17 | # define MSGPACK_PP_INCLUDE_SELF() 18 | # 19 | # endif 20 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/limits.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_LIMITS_HPP 13 | # define MSGPACK_PREPROCESSOR_LIMITS_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/logical.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_LOGICAL_HPP 15 | # define MSGPACK_PREPROCESSOR_LOGICAL_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # include 21 | # include 22 | # include 23 | # include 24 | # include 25 | # include 26 | # include 27 | # include 28 | # 29 | # endif 30 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/logical/and.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_LOGICAL_AND_HPP 15 | # define MSGPACK_PREPROCESSOR_LOGICAL_AND_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_AND */ 22 | # 23 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG() 24 | # define MSGPACK_PP_AND(p, q) MSGPACK_PP_BITAND(MSGPACK_PP_BOOL(p), MSGPACK_PP_BOOL(q)) 25 | # else 26 | # define MSGPACK_PP_AND(p, q) MSGPACK_PP_AND_I(p, q) 27 | # define MSGPACK_PP_AND_I(p, q) MSGPACK_PP_BITAND(MSGPACK_PP_BOOL(p), MSGPACK_PP_BOOL(q)) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/logical/nor.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_LOGICAL_NOR_HPP 15 | # define MSGPACK_PREPROCESSOR_LOGICAL_NOR_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_NOR */ 22 | # 23 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG() 24 | # define MSGPACK_PP_NOR(p, q) MSGPACK_PP_BITNOR(MSGPACK_PP_BOOL(p), MSGPACK_PP_BOOL(q)) 25 | # else 26 | # define MSGPACK_PP_NOR(p, q) MSGPACK_PP_NOR_I(p, q) 27 | # define MSGPACK_PP_NOR_I(p, q) MSGPACK_PP_BITNOR(MSGPACK_PP_BOOL(p), MSGPACK_PP_BOOL(q)) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/logical/not.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_LOGICAL_NOT_HPP 15 | # define MSGPACK_PREPROCESSOR_LOGICAL_NOT_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_NOT */ 22 | # 23 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG() 24 | # define MSGPACK_PP_NOT(x) MSGPACK_PP_COMPL(MSGPACK_PP_BOOL(x)) 25 | # else 26 | # define MSGPACK_PP_NOT(x) MSGPACK_PP_NOT_I(x) 27 | # define MSGPACK_PP_NOT_I(x) MSGPACK_PP_COMPL(MSGPACK_PP_BOOL(x)) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/logical/or.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_LOGICAL_OR_HPP 15 | # define MSGPACK_PREPROCESSOR_LOGICAL_OR_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_OR */ 22 | # 23 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG() 24 | # define MSGPACK_PP_OR(p, q) MSGPACK_PP_BITOR(MSGPACK_PP_BOOL(p), MSGPACK_PP_BOOL(q)) 25 | # else 26 | # define MSGPACK_PP_OR(p, q) MSGPACK_PP_OR_I(p, q) 27 | # define MSGPACK_PP_OR_I(p, q) MSGPACK_PP_BITOR(MSGPACK_PP_BOOL(p), MSGPACK_PP_BOOL(q)) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/logical/xor.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_LOGICAL_XOR_HPP 15 | # define MSGPACK_PREPROCESSOR_LOGICAL_XOR_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_XOR */ 22 | # 23 | # if ~MSGPACK_PP_CONFIG_FLAGS() & MSGPACK_PP_CONFIG_EDG() 24 | # define MSGPACK_PP_XOR(p, q) MSGPACK_PP_BITXOR(MSGPACK_PP_BOOL(p), MSGPACK_PP_BOOL(q)) 25 | # else 26 | # define MSGPACK_PP_XOR(p, q) MSGPACK_PP_XOR_I(p, q) 27 | # define MSGPACK_PP_XOR_I(p, q) MSGPACK_PP_BITXOR(MSGPACK_PP_BOOL(p), MSGPACK_PP_BOOL(q)) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/max.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_MAX_HPP 13 | # define MSGPACK_PREPROCESSOR_MAX_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/min.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_MIN_HPP 13 | # define MSGPACK_PREPROCESSOR_MIN_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/punctuation.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_PUNCTUATION_HPP 13 | # define MSGPACK_PREPROCESSOR_PUNCTUATION_HPP 14 | # 15 | # include 16 | # include 17 | # include 18 | # include 19 | # include 20 | # include 21 | # 22 | # endif 23 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/punctuation/comma.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_PUNCTUATION_COMMA_HPP 15 | # define MSGPACK_PREPROCESSOR_PUNCTUATION_COMMA_HPP 16 | # 17 | # /* MSGPACK_PP_COMMA */ 18 | # 19 | # define MSGPACK_PP_COMMA() , 20 | # 21 | # endif 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/punctuation/paren.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_PUNCTUATION_PAREN_HPP 13 | # define MSGPACK_PREPROCESSOR_PUNCTUATION_PAREN_HPP 14 | # 15 | # /* MSGPACK_PP_LPAREN */ 16 | # 17 | # define MSGPACK_PP_LPAREN() ( 18 | # 19 | # /* MSGPACK_PP_RPAREN */ 20 | # 21 | # define MSGPACK_PP_RPAREN() ) 22 | # 23 | # endif 24 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repeat.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_REPEAT_HPP 13 | # define MSGPACK_PREPROCESSOR_REPEAT_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repeat_2nd.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_REPEAT_2ND_HPP 13 | # define MSGPACK_PREPROCESSOR_REPEAT_2ND_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repeat_3rd.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_REPEAT_3RD_HPP 13 | # define MSGPACK_PREPROCESSOR_REPEAT_3RD_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repeat_from_to.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_REPEAT_FROM_TO_HPP 13 | # define MSGPACK_PREPROCESSOR_REPEAT_FROM_TO_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repeat_from_to_2nd.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_REPEAT_FROM_TO_2ND_HPP 13 | # define MSGPACK_PREPROCESSOR_REPEAT_FROM_TO_2ND_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repeat_from_to_3rd.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_REPEAT_FROM_TO_3RD_HPP 13 | # define MSGPACK_PREPROCESSOR_REPEAT_FROM_TO_3RD_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repetition/deduce_r.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_REPETITION_DEDUCE_R_HPP 13 | # define MSGPACK_PREPROCESSOR_REPETITION_DEDUCE_R_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* MSGPACK_PP_DEDUCE_R */ 19 | # 20 | # define MSGPACK_PP_DEDUCE_R() MSGPACK_PP_AUTO_REC(MSGPACK_PP_FOR_P, 256) 21 | # 22 | # endif 23 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repetition/deduce_z.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_REPETITION_DEDUCE_Z_HPP 13 | # define MSGPACK_PREPROCESSOR_REPETITION_DEDUCE_Z_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* MSGPACK_PP_DEDUCE_Z */ 19 | # 20 | # define MSGPACK_PP_DEDUCE_Z() MSGPACK_PP_AUTO_REC(MSGPACK_PP_REPEAT_P, 4) 21 | # 22 | # endif 23 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repetition/enum_params_with_a_default.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_REPETITION_ENUM_PARAMS_WITH_A_DEFAULT_HPP 15 | # define MSGPACK_PREPROCESSOR_REPETITION_ENUM_PARAMS_WITH_A_DEFAULT_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* MSGPACK_PP_ENUM_PARAMS_WITH_A_DEFAULT */ 22 | # 23 | # define MSGPACK_PP_ENUM_PARAMS_WITH_A_DEFAULT(count, param, def) MSGPACK_PP_ENUM_BINARY_PARAMS(count, param, = def MSGPACK_PP_INTERCEPT) 24 | # 25 | # endif 26 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/repetition/enum_params_with_defaults.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_REPETITION_ENUM_PARAMS_WITH_DEFAULTS_HPP 15 | # define MSGPACK_PREPROCESSOR_REPETITION_ENUM_PARAMS_WITH_DEFAULTS_HPP 16 | # 17 | # include 18 | # include 19 | # 20 | # /* MSGPACK_PP_ENUM_PARAMS_WITH_DEFAULTS */ 21 | # 22 | # define MSGPACK_PP_ENUM_PARAMS_WITH_DEFAULTS(count, param, def) MSGPACK_PP_ENUM_BINARY_PARAMS(count, param, = def) 23 | # 24 | # endif 25 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/selection.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_SELECTION_HPP 13 | # define MSGPACK_PREPROCESSOR_SELECTION_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # endif 19 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/seq/push_back.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_SEQ_PUSH_BACK_HPP 13 | # define MSGPACK_PREPROCESSOR_SEQ_PUSH_BACK_HPP 14 | # 15 | # /* MSGPACK_PP_SEQ_PUSH_BACK */ 16 | # 17 | # define MSGPACK_PP_SEQ_PUSH_BACK(seq, elem) seq(elem) 18 | # 19 | # endif 20 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/seq/push_front.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_SEQ_PUSH_FRONT_HPP 13 | # define MSGPACK_PREPROCESSOR_SEQ_PUSH_FRONT_HPP 14 | # 15 | # /* MSGPACK_PP_SEQ_PUSH_FRONT */ 16 | # 17 | # define MSGPACK_PP_SEQ_PUSH_FRONT(seq, elem) (elem)seq 18 | # 19 | # endif 20 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/slot.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_SLOT_HPP 13 | # define MSGPACK_PREPROCESSOR_SLOT_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/slot/counter.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2005. * 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_SLOT_COUNTER_HPP 13 | # define MSGPACK_PREPROCESSOR_SLOT_COUNTER_HPP 14 | # 15 | # include 16 | # 17 | # /* MSGPACK_PP_COUNTER */ 18 | # 19 | # define MSGPACK_PP_COUNTER 0 20 | # 21 | # /* MSGPACK_PP_UPDATE_COUNTER */ 22 | # 23 | # define MSGPACK_PP_UPDATE_COUNTER() 24 | # 25 | # endif 26 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/tuple/enum.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Edward Diener 2011. * 4 | # * (C) Copyright Paul Mensonides 2011. * 5 | # * Distributed under the Boost Software License, Version 1.0. (See * 6 | # * accompanying file LICENSE_1_0.txt or copy at * 7 | # * http://www.boost.org/LICENSE_1_0.txt) * 8 | # * * 9 | # ************************************************************************** */ 10 | # 11 | # /* See http://www.boost.org for most recent version. */ 12 | # 13 | # ifndef MSGPACK_PREPROCESSOR_TUPLE_ENUM_HPP 14 | # define MSGPACK_PREPROCESSOR_TUPLE_ENUM_HPP 15 | # 16 | # include 17 | # 18 | # /* MSGPACK_PP_TUPLE_ENUM */ 19 | # 20 | # define MSGPACK_PP_TUPLE_ENUM MSGPACK_PP_TUPLE_REM_CTOR 21 | # 22 | # endif 23 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/variadic/to_tuple.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Edward Diener 2011. * 4 | # * (C) Copyright Paul Mensonides 2011. * 5 | # * Distributed under the Boost Software License, Version 1.0. (See * 6 | # * accompanying file LICENSE_1_0.txt or copy at * 7 | # * http://www.boost.org/LICENSE_1_0.txt) * 8 | # * * 9 | # ************************************************************************** */ 10 | # 11 | # /* See http://www.boost.org for most recent version. */ 12 | # 13 | # ifndef MSGPACK_PREPROCESSOR_VARIADIC_TO_TUPLE_HPP 14 | # define MSGPACK_PREPROCESSOR_VARIADIC_TO_TUPLE_HPP 15 | # 16 | # include 17 | # 18 | # /* MSGPACK_PP_VARIADIC_TO_TUPLE */ 19 | # 20 | # if MSGPACK_PP_VARIADICS 21 | # define MSGPACK_PP_VARIADIC_TO_TUPLE(...) (__VA_ARGS__) 22 | # endif 23 | # 24 | # endif 25 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/preprocessor/while.hpp: -------------------------------------------------------------------------------- 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 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef MSGPACK_PREPROCESSOR_WHILE_HPP 13 | # define MSGPACK_PREPROCESSOR_WHILE_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/sbuffer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ simple buffer implementation 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_SBUFFER_HPP 11 | #define MSGPACK_SBUFFER_HPP 12 | 13 | #include "msgpack/sbuffer_decl.hpp" 14 | 15 | #include "msgpack/v1/sbuffer.hpp" 16 | 17 | #endif // MSGPACK_SBUFFER_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/sbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ simple buffer implementation 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_SBUFFER_DECL_HPP 11 | #define MSGPACK_SBUFFER_DECL_HPP 12 | 13 | #include "msgpack/v1/sbuffer_decl.hpp" 14 | #include "msgpack/v2/sbuffer_decl.hpp" 15 | 16 | 17 | #endif // MSGPACK_SBUFFER_DECL_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/unpack.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deserializing routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_UNPACK_HPP 11 | #define MSGPACK_UNPACK_HPP 12 | 13 | #include "msgpack/unpack_decl.hpp" 14 | 15 | #include "msgpack/v1/unpack.hpp" 16 | #include "msgpack/v2/unpack.hpp" 17 | #include "msgpack/v2/x3_unpack.hpp" 18 | 19 | #endif // MSGPACK_UNPACK_HPP 20 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/unpack_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deserializing routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_UNPACK_DECL_HPP 11 | #define MSGPACK_UNPACK_DECL_HPP 12 | 13 | #include "msgpack/v1/unpack_decl.hpp" 14 | #include "msgpack/v2/unpack_decl.hpp" 15 | 16 | #endif // MSGPACK_UNPACK_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/unpack_exception.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deserializing routine 3 | // 4 | // Copyright (C) 2017 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_UNPACK_EXCEPTION_HPP 11 | #define MSGPACK_UNPACK_EXCEPTION_HPP 12 | 13 | #include "msgpack/v1/unpack_exception.hpp" 14 | 15 | #endif // MSGPACK_UNPACK_EXCEPTION_HPP 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/util.h: -------------------------------------------------------------------------------- 1 | /* 2 | * MessagePack for C utilities 3 | * 4 | * Copyright (C) 2014 FURUHASHI Sadayuki 5 | * 6 | * Distributed under the Boost Software License, Version 1.0. 7 | * (See accompanying file LICENSE_1_0.txt or copy at 8 | * http://www.boost.org/LICENSE_1_0.txt) 9 | */ 10 | #ifndef MSGPACK_UTIL_H 11 | #define MSGPACK_UTIL_H 12 | 13 | #define MSGPACK_UNUSED(a) (void)(a) 14 | 15 | #endif /* MSGPACK_UTIL_H */ 16 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/define.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_DEFINE_HPP 11 | #define MSGPACK_V1_DEFINE_HPP 12 | 13 | #if defined(MSGPACK_USE_CPP03) 14 | #include "msgpack/v1/adaptor/detail/cpp03_define_array.hpp" 15 | #include "msgpack/v1/adaptor/detail/cpp03_define_map.hpp" 16 | #else // MSGPACK_USE_CPP03 17 | #include "msgpack/v1/adaptor/detail/cpp11_define_array.hpp" 18 | #include "msgpack/v1/adaptor/detail/cpp11_define_map.hpp" 19 | #endif // MSGPACK_USE_CPP03 20 | 21 | #endif // MSGPACK_V1_DEFINE_HPP 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/define_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_DEFINE_DECL_HPP 11 | #define MSGPACK_V1_DEFINE_DECL_HPP 12 | 13 | #include "msgpack/cpp_config.hpp" 14 | 15 | #if defined(MSGPACK_USE_CPP03) 16 | #include "msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp" 17 | #include "msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp" 18 | #else // MSGPACK_USE_CPP03 19 | #include "msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp" 20 | #include "msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp" 21 | #endif // MSGPACK_USE_CPP03 22 | 23 | #endif // MSGPACK_V1_DEFINE_DECL_HPP 24 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/detail/cpp11_convert_helper.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2017 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_CPP11_CONVERT_HELPER_HPP 11 | #define MSGPACK_V1_CPP11_CONVERT_HELPER_HPP 12 | 13 | #include 14 | 15 | #include 16 | 17 | namespace msgpack { 18 | /// @cond 19 | MSGPACK_API_VERSION_NAMESPACE(v1) { 20 | /// @endcond 21 | namespace type { 22 | 23 | template 24 | inline typename std::enable_if< 25 | has_as::value 26 | >::type 27 | convert_helper(msgpack::object const& o, T& t) { 28 | t = o.as(); 29 | } 30 | template 31 | inline typename std::enable_if< 32 | !has_as::value 33 | >::type 34 | convert_helper(msgpack::object const& o, T& t) { 35 | o.convert(t); 36 | } 37 | 38 | } // namespace type 39 | 40 | /// @cond 41 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 42 | /// @endcond 43 | } // namespace msgpack 44 | 45 | #endif // MSGPACK_V1_CPP11_CONVERT_HELPER_HPP 46 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_CPP11_DEFINE_ARRAY_DECL_HPP 11 | #define MSGPACK_V1_CPP11_DEFINE_ARRAY_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | #include "msgpack/adaptor/adaptor_base.hpp" 15 | 16 | namespace msgpack { 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v1) { 19 | /// @endcond 20 | namespace type { 21 | 22 | template 23 | struct define_array_imp; 24 | 25 | template 26 | struct define_array; 27 | 28 | define_array<> make_define_array(); 29 | 30 | template 31 | inline define_array make_define_array(Args&... args); 32 | 33 | } // namespace type 34 | /// @cond 35 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 36 | /// @endcond 37 | } // namespace msgpack 38 | 39 | #endif // MSGPACK_V1_CPP11_DEFINE_ARRAY_DECL_HPP 40 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_CPP11_DEFINE_MAP_DECL_HPP 11 | #define MSGPACK_V1_CPP11_DEFINE_MAP_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | #include "msgpack/adaptor/adaptor_base.hpp" 15 | 16 | namespace msgpack { 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v1) { 19 | /// @endcond 20 | namespace type { 21 | 22 | template 23 | struct define_map_imp; 24 | 25 | template 26 | struct define_map; 27 | 28 | template 29 | define_map make_define_map(Args&... args); 30 | 31 | } // namespace type 32 | /// @cond 33 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 34 | /// @endcond 35 | } // namespace msgpack 36 | 37 | #endif // MSGPACK_V1_CPP11_DEFINE_MAP_DECL_HPP 38 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/ext_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_TYPE_EXT_DECL_HPP 11 | #define MSGPACK_V1_TYPE_EXT_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | #include "msgpack/adaptor/adaptor_base.hpp" 15 | #include 16 | #include 17 | #include 18 | 19 | namespace msgpack { 20 | 21 | /// @cond 22 | MSGPACK_API_VERSION_NAMESPACE(v1) { 23 | /// @endcond 24 | 25 | namespace type { 26 | 27 | class ext_ref; 28 | class ext; 29 | 30 | } // namespace type 31 | 32 | /// @cond 33 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 34 | /// @endcond 35 | 36 | } // namespace msgpack 37 | 38 | #endif // MSGPACK_V1_TYPE_EXT_DECL_HPP 39 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/map_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_TYPE_MAP_DECL_HPP 11 | #define MSGPACK_V1_TYPE_MAP_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | 15 | #include 16 | 17 | namespace msgpack { 18 | 19 | /// @cond 20 | MSGPACK_API_VERSION_NAMESPACE(v1) { 21 | /// @endcond 22 | 23 | namespace type { 24 | 25 | template , typename Alloc = std::allocator > > 26 | class assoc_vector; 27 | 28 | } //namespace type 29 | 30 | /// @cond 31 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 32 | /// @endcond 33 | 34 | } // namespace msgpack 35 | 36 | #endif // MSGPACK_V1_TYPE_MAP_DECL_HPP 37 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/msgpack_tuple.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_MSGPACK_TUPLE_HPP 11 | #define MSGPACK_V1_MSGPACK_TUPLE_HPP 12 | 13 | #include "msgpack/cpp_config.hpp" 14 | 15 | #if defined(MSGPACK_USE_CPP03) 16 | #include "msgpack/v1/adaptor/detail/cpp03_msgpack_tuple.hpp" 17 | #else // MSGPACK_USE_CPP03 18 | #include "msgpack/v1/adaptor/detail/cpp11_msgpack_tuple.hpp" 19 | #endif // MSGPACK_USE_CPP03 20 | 21 | #endif // MSGPACK_V1_MSGPACK_TUPLE_HPP 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/msgpack_tuple_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_MSGPACK_TUPLE_DECL_HPP 11 | #define MSGPACK_V1_MSGPACK_TUPLE_DECL_HPP 12 | 13 | #include "msgpack/cpp_config.hpp" 14 | 15 | #if defined(MSGPACK_USE_CPP03) 16 | #include "msgpack/v1/adaptor/detail/cpp03_msgpack_tuple_decl.hpp" 17 | #else // MSGPACK_USE_CPP03 18 | #include "msgpack/v1/adaptor/detail/cpp11_msgpack_tuple_decl.hpp" 19 | #endif // MSGPACK_USE_CPP03 20 | 21 | #endif // MSGPACK_V1_MSGPACK_TUPLE_DECL_HPP 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/nil_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_TYPE_NIL_DECL_HPP 11 | #define MSGPACK_V1_TYPE_NIL_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | #include "msgpack/adaptor/adaptor_base.hpp" 15 | 16 | namespace msgpack { 17 | 18 | /// @cond 19 | MSGPACK_API_VERSION_NAMESPACE(v1) { 20 | /// @endcond 21 | 22 | namespace type { 23 | 24 | struct nil_t; 25 | 26 | #if !defined(MSGPACK_DISABLE_LEGACY_NIL) 27 | 28 | typedef nil_t nil; 29 | 30 | #endif // !defined(MSGPACK_DISABLE_LEGACY_NIL) 31 | 32 | bool operator<(nil_t const& lhs, nil_t const& rhs); 33 | 34 | bool operator==(nil_t const& lhs, nil_t const& rhs); 35 | 36 | } // namespace type 37 | 38 | /// @cond 39 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 40 | /// @endcond 41 | 42 | } // namespace msgpack 43 | 44 | #endif // MSGPACK_V1_TYPE_NIL_DECL_HPP 45 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/raw_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_TYPE_RAW_DECL_HPP 11 | #define MSGPACK_V1_TYPE_RAW_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | #include "msgpack/adaptor/adaptor_base.hpp" 15 | #include 16 | #include 17 | 18 | namespace msgpack { 19 | 20 | /// @cond 21 | MSGPACK_API_VERSION_NAMESPACE(v1) { 22 | /// @endcond 23 | 24 | namespace type { 25 | 26 | struct raw_ref; 27 | 28 | } // namespace type 29 | 30 | /// @cond 31 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 32 | /// @endcond 33 | 34 | } // namespace msgpack 35 | 36 | #endif // MSGPACK_V1_TYPE_RAW_DECL_HPP 37 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/adaptor/v4raw_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_TYPE_V4RAW_DECL_HPP 11 | #define MSGPACK_V1_TYPE_V4RAW_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | #include "msgpack/adaptor/adaptor_base.hpp" 15 | 16 | namespace msgpack { 17 | 18 | /// @cond 19 | MSGPACK_API_VERSION_NAMESPACE(v1) { 20 | /// @endcond 21 | 22 | namespace type { 23 | 24 | struct v4raw_ref; 25 | 26 | } // namespace type 27 | 28 | /// @cond 29 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 30 | /// @endcond 31 | 32 | } // namespace msgpack 33 | 34 | #endif // MSGPACK_V1_TYPE_V4RAW_DECL_HPP 35 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/fbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ FILE* buffer adaptor 3 | // 4 | // Copyright (C) 2013-2016 Vladimir Volodko and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_FBUFFER_DECL_HPP 11 | #define MSGPACK_V1_FBUFFER_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | 15 | #include 16 | #include 17 | 18 | namespace msgpack { 19 | 20 | /// @cond 21 | MSGPACK_API_VERSION_NAMESPACE(v1) { 22 | /// @endcond 23 | 24 | class fbuffer; 25 | 26 | /// @cond 27 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 28 | /// @endcond 29 | 30 | } // namespace msgpack 31 | 32 | #endif // MSGPACK_V1_FBUFFER_DECL_HPP 33 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/parse_return.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deserializing routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_PARSE_RETURN_HPP 11 | #define MSGPACK_V1_PARSE_RETURN_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v1) { 19 | /// @endcond 20 | 21 | 22 | // for internal use 23 | typedef enum { 24 | PARSE_SUCCESS = 2, 25 | PARSE_EXTRA_BYTES = 1, 26 | PARSE_CONTINUE = 0, 27 | PARSE_PARSE_ERROR = -1 28 | } parse_return; 29 | 30 | /// @cond 31 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 32 | /// @endcond 33 | 34 | } // namespace msgpack 35 | 36 | #endif // MSGPACK_V1_PARSE_RETURN_HPP 37 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/preprocessor.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org/libs/preprocessor for documentation. */ 13 | # 14 | # ifndef MSGPACK_PREPROCESSOR_HPP 15 | # define MSGPACK_PREPROCESSOR_HPP 16 | # 17 | # include 18 | # 19 | # endif 20 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/sbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ simple buffer implementation 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_SBUFFER_DECL_HPP 11 | #define MSGPACK_V1_SBUFFER_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | 15 | #ifndef MSGPACK_SBUFFER_INIT_SIZE 16 | #define MSGPACK_SBUFFER_INIT_SIZE 8192 17 | #endif 18 | 19 | namespace msgpack { 20 | 21 | /// @cond 22 | MSGPACK_API_VERSION_NAMESPACE(v1) { 23 | /// @endcond 24 | 25 | class sbuffer; 26 | 27 | /// @cond 28 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 29 | /// @endcond 30 | 31 | } // namespace msgpack 32 | 33 | #endif // MSGPACK_V1_SBUFFER_DECL_HPP 34 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/version.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * MessagePack for C++ version information 3 | * 4 | * Copyright (C) 2008-2013 FURUHASHI Sadayuki and Takatoshi Kondo 5 | * 6 | * Distributed under the Boost Software License, Version 1.0. 7 | * (See accompanying file LICENSE_1_0.txt or copy at 8 | * http://www.boost.org/LICENSE_1_0.txt) 9 | */ 10 | #ifndef MSGPACK_VERSION_HPP 11 | #define MSGPACK_VERSION_HPP 12 | 13 | #include "version_master.h" 14 | 15 | #define MSGPACK_STR(v) #v 16 | #define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) 17 | 18 | #define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) 19 | 20 | inline const char* msgpack_version(void) { 21 | return MSGPACK_VERSION; 22 | } 23 | 24 | inline int msgpack_version_major(void) { 25 | return MSGPACK_VERSION_MAJOR; 26 | } 27 | 28 | inline int msgpack_version_minor(void) { 29 | return MSGPACK_VERSION_MINOR; 30 | } 31 | 32 | inline int msgpack_version_revision(void) { 33 | return MSGPACK_VERSION_REVISION; 34 | } 35 | 36 | #endif /* msgpack/version.hpp */ 37 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/vrefbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ zero-copy buffer implementation 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_VREFBUFFER_DECL_HPP 11 | #define MSGPACK_V1_VREFBUFFER_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | 15 | #include 16 | 17 | #ifndef MSGPACK_VREFBUFFER_REF_SIZE 18 | #define MSGPACK_VREFBUFFER_REF_SIZE 32 19 | #endif 20 | 21 | #ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE 22 | #define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192 23 | #endif 24 | 25 | namespace msgpack { 26 | 27 | /// @cond 28 | MSGPACK_API_VERSION_NAMESPACE(v1) { 29 | /// @endcond 30 | 31 | class vrefbuffer; 32 | 33 | /// @cond 34 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 35 | /// @endcond 36 | 37 | } // namespace msgpack 38 | 39 | #endif // MSGPACK_V1_VREFBUFFER_DECL_HPP 40 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/zbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deflate buffer implementation 3 | // 4 | // Copyright (C) 2010-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_ZBUFFER_DECL_HPP 11 | #define MSGPACK_V1_ZBUFFER_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | 15 | #ifndef MSGPACK_ZBUFFER_RESERVE_SIZE 16 | #define MSGPACK_ZBUFFER_RESERVE_SIZE 512 17 | #endif 18 | 19 | #ifndef MSGPACK_ZBUFFER_INIT_SIZE 20 | #define MSGPACK_ZBUFFER_INIT_SIZE 8192 21 | #endif 22 | 23 | namespace msgpack { 24 | 25 | /// @cond 26 | MSGPACK_API_VERSION_NAMESPACE(v1) { 27 | /// @endcond 28 | 29 | class zbuffer; 30 | 31 | /// @cond 32 | } // MSGPACK_API_VERSION_NAMESPACE(v1) 33 | /// @endcond 34 | 35 | } // namespace msgpack 36 | 37 | #endif // MSGPACK_V1_ZBUFFER_DECL_HPP 38 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/zone.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ memory pool 3 | // 4 | // Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_ZONE_HPP 11 | #define MSGPACK_V1_ZONE_HPP 12 | 13 | #include "msgpack/cpp_config.hpp" 14 | 15 | #if defined(MSGPACK_USE_CPP03) 16 | #include "msgpack/v1/detail/cpp03_zone.hpp" 17 | #else // MSGPACK_USE_CPP03 18 | #include "msgpack/v1/detail/cpp11_zone.hpp" 19 | #endif // MSGPACK_USE_CPP03 20 | 21 | #endif // MSGPACK_V1_ZONE_HPP 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v1/zone_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ memory pool 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V1_ZONE_DECL_HPP 11 | #define MSGPACK_V1_ZONE_DECL_HPP 12 | 13 | #include "msgpack/cpp_config.hpp" 14 | 15 | #if defined(MSGPACK_USE_CPP03) 16 | #include "msgpack/v1/detail/cpp03_zone_decl.hpp" 17 | #else // MSGPACK_USE_CPP03 18 | #include "msgpack/v1/detail/cpp11_zone_decl.hpp" 19 | #endif // MSGPACK_USE_CPP03 20 | 21 | #endif // MSGPACK_V1_ZONE_DECL_HPP 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/array_ref_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_ARRAY_REF_DECL_HPP 11 | #define MSGPACK_V2_TYPE_ARRAY_REF_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/array_ref_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | namespace type { 22 | 23 | using v1::type::array_ref; 24 | 25 | using v1::type::make_array_ref; 26 | 27 | 28 | } // namespace type 29 | 30 | /// @cond 31 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 32 | /// @endcond 33 | 34 | } // namespace msgpack 35 | 36 | #endif // MSGPACK_V2_TYPE_ARRAY_REF_DECL_HPP 37 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/boost/msgpack_variant_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP 11 | #define MSGPACK_V2_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP 12 | 13 | #if defined(MSGPACK_USE_BOOST) 14 | 15 | #include "msgpack/v1/adaptor/boost/msgpack_variant_decl.hpp" 16 | 17 | namespace msgpack { 18 | 19 | /// @cond 20 | MSGPACK_API_VERSION_NAMESPACE(v2) { 21 | /// @endcond 22 | 23 | namespace type { 24 | 25 | using v1::type::basic_variant; 26 | using v1::type::variant; 27 | using v1::type::variant_ref; 28 | 29 | using v1::type::operator<; 30 | 31 | using v1::type::operator==; 32 | 33 | } // namespace type 34 | 35 | /// @cond 36 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 37 | /// @endcond 38 | 39 | } // namespace msgpack 40 | 41 | #endif // MSGPACK_USE_BOOST 42 | #endif // MSGPACK_V2_TYPE_BOOST_MSGPACK_VARIANT_DECL_HPP 43 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/check_container_size_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_CHECK_CONTAINER_SIZE_DECL_HPP 11 | #define MSGPACK_V2_CHECK_CONTAINER_SIZE_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/check_container_size_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | using v1::container_size_overflow; 22 | 23 | namespace detail { 24 | 25 | using v1::detail::check_container_size; 26 | 27 | using v1::detail::check_container_size_for_ext; 28 | 29 | } // namespace detail 30 | 31 | using v1::checked_get_container_size; 32 | 33 | /// @cond 34 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 35 | /// @endcond 36 | 37 | } // namespace msgpack 38 | 39 | #endif // MSGPACK_V2_CHECK_CONTAINER_SIZE_DECL_HPP 40 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/define_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_DEFINE_DECL_HPP 11 | #define MSGPACK_V2_DEFINE_DECL_HPP 12 | 13 | #include "msgpack/cpp_config.hpp" 14 | 15 | #if defined(MSGPACK_USE_CPP03) 16 | #include "msgpack/v2/adaptor/detail/cpp03_define_array_decl.hpp" 17 | #include "msgpack/v2/adaptor/detail/cpp03_define_map_decl.hpp" 18 | #else // MSGPACK_USE_CPP03 19 | #include "msgpack/v2/adaptor/detail/cpp11_define_array_decl.hpp" 20 | #include "msgpack/v2/adaptor/detail/cpp11_define_map_decl.hpp" 21 | #endif // MSGPACK_USE_CPP03 22 | 23 | #endif // MSGPACK_V2_DEFINE_DECL_HPP 24 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/detail/cpp03_define_array_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_CPP03_DEFINE_ARRAY_DECL_HPP 11 | #define MSGPACK_V2_CPP03_DEFINE_ARRAY_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/detail/cpp03_define_array_decl.hpp" 14 | 15 | namespace msgpack { 16 | /// @cond 17 | MSGPACK_API_VERSION_NAMESPACE(v2) { 18 | /// @endcond 19 | namespace type { 20 | 21 | using v1::type::define_array; 22 | 23 | using v1::type::make_define_array; 24 | 25 | } // namespace type 26 | /// @cond 27 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 28 | /// @endcond 29 | } // namespace msgpack 30 | 31 | #endif // MSGPACK_V2_CPP03_DEFINE_ARRAY_DECL_HPP 32 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/detail/cpp03_define_map_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_CPP03_DEFINE_MAP_DECL_HPP 11 | #define MSGPACK_V2_CPP03_DEFINE_MAP_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/detail/cpp03_define_map_decl.hpp" 14 | 15 | namespace msgpack { 16 | /// @cond 17 | MSGPACK_API_VERSION_NAMESPACE(v2) { 18 | /// @endcond 19 | namespace type { 20 | 21 | using v1::type::define_map; 22 | 23 | using v1::type::make_define_map; 24 | 25 | } // namespace type 26 | /// @cond 27 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 28 | /// @endcond 29 | } // namespace msgpack 30 | 31 | #endif // MSGPACK_V2_CPP03_DEFINE_MAP_DECL_HPP 32 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/detail/cpp03_msgpack_tuple_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_CPP03_MSGPACK_TUPLE_DECL_HPP 11 | #define MSGPACK_V2_CPP03_MSGPACK_TUPLE_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/detail/cpp03_msgpack_tuple_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | namespace type { 22 | 23 | using v1::type::tuple; 24 | 25 | using v1::type::tuple_element; 26 | 27 | using v1::type::const_tuple_element; 28 | 29 | using v1::type::tuple_type; 30 | 31 | using v1::type::get; 32 | 33 | using v1::type::make_tuple; 34 | 35 | } // namespace type 36 | 37 | /// @cond 38 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 39 | /// @endcond 40 | 41 | } // namespace msgpack 42 | 43 | #endif // MSGPACK_V2_CPP03_MSGPACK_TUPLE_DECL_HPP 44 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/detail/cpp11_define_array_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_CPP11_DEFINE_ARRAY_DECL_HPP 11 | #define MSGPACK_V2_CPP11_DEFINE_ARRAY_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/detail/cpp11_define_array_decl.hpp" 14 | 15 | namespace msgpack { 16 | /// @cond 17 | MSGPACK_API_VERSION_NAMESPACE(v2) { 18 | /// @endcond 19 | namespace type { 20 | 21 | using v1::type::define_array_imp; 22 | using v1::type::define_array; 23 | 24 | using v1::type::make_define_array; 25 | 26 | } // namespace type 27 | /// @cond 28 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 29 | /// @endcond 30 | } // namespace msgpack 31 | 32 | #endif // MSGPACK_V2_CPP11_DEFINE_ARRAY_DECL_HPP 33 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/detail/cpp11_define_map_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_CPP11_DEFINE_MAP_DECL_HPP 11 | #define MSGPACK_V2_CPP11_DEFINE_MAP_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/detail/cpp11_define_map_decl.hpp" 14 | 15 | namespace msgpack { 16 | /// @cond 17 | MSGPACK_API_VERSION_NAMESPACE(v2) { 18 | /// @endcond 19 | namespace type { 20 | 21 | using v1::type::define_map_imp; 22 | using v1::type::define_map; 23 | using v1::type::make_define_map; 24 | 25 | } // namespace type 26 | /// @cond 27 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 28 | /// @endcond 29 | } // namespace msgpack 30 | 31 | #endif // MSGPACK_V2_CPP11_DEFINE_MAP_DECL_HPP 32 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/ext_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_EXT_DECL_HPP 11 | #define MSGPACK_V2_TYPE_EXT_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/ext_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | namespace type { 22 | 23 | using v1::type::ext_ref; 24 | using v1::type::ext; 25 | 26 | } // namespace type 27 | 28 | /// @cond 29 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 30 | /// @endcond 31 | 32 | } // namespace msgpack 33 | 34 | #endif // MSGPACK_V2_TYPE_EXT_DECL_HPP 35 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/fixint_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_FIXINT_DECL_HPP 11 | #define MSGPACK_V2_TYPE_FIXINT_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/fixint_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | namespace type { 22 | 23 | using v1::type::fix_int; 24 | 25 | using v1::type::fix_uint8; 26 | using v1::type::fix_uint16; 27 | using v1::type::fix_uint32; 28 | using v1::type::fix_uint64; 29 | 30 | using v1::type::fix_int8; 31 | using v1::type::fix_int16; 32 | using v1::type::fix_int32; 33 | using v1::type::fix_int64; 34 | 35 | } // namespace type 36 | 37 | /// @cond 38 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 39 | /// @endcond 40 | 41 | } // namespace msgpack 42 | 43 | #endif // MSGPACK_V2_TYPE_FIXINT_DECL_HPP 44 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/map_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_MAP_DECL_HPP 11 | #define MSGPACK_V2_TYPE_MAP_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/map_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | namespace type { 22 | 23 | using v1::type::assoc_vector; 24 | 25 | } //namespace type 26 | 27 | /// @cond 28 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 29 | /// @endcond 30 | 31 | } // namespace msgpack 32 | 33 | #endif // MSGPACK_V2_TYPE_MAP_DECL_HPP 34 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/msgpack_tuple_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_MSGPACK_TUPLE_DECL_HPP 11 | #define MSGPACK_V2_MSGPACK_TUPLE_DECL_HPP 12 | 13 | #include "msgpack/cpp_config.hpp" 14 | 15 | #if defined(MSGPACK_USE_CPP03) 16 | #include "msgpack/v2/adaptor/detail/cpp03_msgpack_tuple_decl.hpp" 17 | #else // MSGPACK_USE_CPP03 18 | #include "msgpack/v2/adaptor/detail/cpp11_msgpack_tuple_decl.hpp" 19 | #endif // MSGPACK_USE_CPP03 20 | 21 | #endif // MSGPACK_V2_MSGPACK_TUPLE_DECL_HPP 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/nil_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_NIL_DECL_HPP 11 | #define MSGPACK_V2_TYPE_NIL_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/nil_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | namespace type { 22 | 23 | using v1::type::nil_t; 24 | 25 | #if defined(MSGPACK_USE_LEGACY_NIL) 26 | 27 | typedef nil_t nil; 28 | 29 | #endif // defined(MSGPACK_USE_LEGACY_NIL) 30 | 31 | using v1::type::operator<; 32 | using v1::type::operator==; 33 | 34 | } // namespace type 35 | 36 | /// @cond 37 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 38 | /// @endcond 39 | 40 | } // namespace msgpack 41 | 42 | #endif // MSGPACK_V2_TYPE_NIL_DECL_HPP 43 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/raw_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_RAW_DECL_HPP 11 | #define MSGPACK_V2_TYPE_RAW_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/raw_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | namespace type { 22 | 23 | using v1::type::raw_ref; 24 | 25 | } // namespace type 26 | 27 | /// @cond 28 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 29 | /// @endcond 30 | 31 | } // namespace msgpack 32 | 33 | #endif // MSGPACK_V2_TYPE_RAW_DECL_HPP 34 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/size_equal_only_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_SIZE_EQUAL_ONLY_DECL_HPP 11 | #define MSGPACK_V2_TYPE_SIZE_EQUAL_ONLY_DECL_HPP 12 | 13 | #include "msgpack/v1/adaptor/size_equal_only_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | namespace type { 22 | 23 | using v1::type::size_equal_only; 24 | using v1::type::make_size_equal_only; 25 | using v1::type::size; 26 | 27 | } // namespace type 28 | 29 | /// @cond 30 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 31 | /// @endcond 32 | 33 | } // namespace msgpack 34 | 35 | #endif // MSGPACK_V2_TYPE_SIZE_EQUAL_ONLY_DECL_HPP 36 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/adaptor/v4raw_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_TYPE_V4RAW_DECL_HPP 11 | #define MSGPACK_V2_TYPE_V4RAW_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | #include "msgpack/adaptor/adaptor_base.hpp" 15 | 16 | namespace msgpack { 17 | 18 | /// @cond 19 | MSGPACK_API_VERSION_NAMESPACE(v2) { 20 | /// @endcond 21 | 22 | namespace type { 23 | 24 | using v1::type::v4raw_ref; 25 | 26 | } // namespace type 27 | 28 | /// @cond 29 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 30 | /// @endcond 31 | 32 | } // namespace msgpack 33 | 34 | #endif // MSGPACK_V2_TYPE_V4RAW_DECL_HPP 35 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/detail/cpp03_zone_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ memory pool 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_CPP03_ZONE_DECL_HPP 11 | #define MSGPACK_V2_CPP03_ZONE_DECL_HPP 12 | 13 | #include "msgpack/v1/detail/cpp03_zone_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | using v1::zone; 22 | 23 | using v1::aligned_size; 24 | 25 | /// @cond 26 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 27 | /// @endcond 28 | 29 | } // namespace msgpack 30 | 31 | #endif // MSGPACK_V2_CPP03_ZONE_DECL_HPP 32 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/detail/cpp11_zone_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ memory pool 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_CPP11_ZONE_DECL_HPP 11 | #define MSGPACK_V2_CPP11_ZONE_DECL_HPP 12 | 13 | #include "msgpack/v1/zone_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | using v1::zone; 22 | 23 | using v1::aligned_size; 24 | 25 | /// @cond 26 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 27 | /// @endcond 28 | 29 | } // namespace msgpack 30 | 31 | #endif // MSGPACK_V2_CPP11_ZONE_DECL_HPP 32 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/fbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ FILE* buffer adaptor 3 | // 4 | // Copyright (C) 2013-2016 Vladimir Volodko and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_FBUFFER_DECL_HPP 11 | #define MSGPACK_V2_FBUFFER_DECL_HPP 12 | 13 | #include "msgpack/v1/fbuffer_decl.hpp" 14 | 15 | #include 16 | #include 17 | 18 | namespace msgpack { 19 | 20 | /// @cond 21 | MSGPACK_API_VERSION_NAMESPACE(v2) { 22 | /// @endcond 23 | 24 | using v1::fbuffer; 25 | 26 | /// @cond 27 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 28 | /// @endcond 29 | 30 | } // namespace msgpack 31 | 32 | #endif // MSGPACK_V2_FBUFFER_DECL_HPP 33 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/iterator_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_V2_ITERATOR_DECL_HPP 12 | #define MSGPACK_V2_ITERATOR_DECL_HPP 13 | #if !defined(MSGPACK_USE_CPP03) 14 | 15 | #include 16 | 17 | namespace msgpack { 18 | 19 | /// @cond 20 | MSGPACK_API_VERSION_NAMESPACE(v2) { 21 | /// @endcond 22 | 23 | using v1::begin; 24 | using v1::end; 25 | 26 | /// @cond 27 | } 28 | /// @endcond 29 | 30 | } 31 | 32 | #endif // !defined(MSGPACK_USE_CPP03) 33 | #endif // MSGPACK_V2_ITERATOR_DECL_HPP 34 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/meta_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2015-2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef MSGPACK_V2_META_DECL_HPP 12 | #define MSGPACK_V2_META_DECL_HPP 13 | 14 | #if !defined(MSGPACK_USE_CPP03) 15 | 16 | #include "msgpack/v1/meta_decl.hpp" 17 | 18 | namespace msgpack { 19 | 20 | /// @cond 21 | MSGPACK_API_VERSION_NAMESPACE(v2) { 22 | /// @endcond 23 | 24 | namespace detail { 25 | 26 | using v1::detail::bool_pack; 27 | 28 | using v1::detail::all_of_imp; 29 | 30 | using v1::detail::any_of_imp; 31 | 32 | } // namespace detail 33 | 34 | using v1::all_of; 35 | 36 | using v1::any_of; 37 | 38 | using v1::seq; 39 | 40 | using v1::gen_seq; 41 | 42 | /// @cond 43 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 44 | /// @endcond 45 | 46 | } // namespace msgpack 47 | 48 | #endif // !defined(MSGPACK_USE_CPP03) 49 | 50 | #endif // MSGPACK_V2_META_DECL_HPP 51 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/object.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_OBJECT_HPP 11 | #define MSGPACK_V2_OBJECT_HPP 12 | 13 | #include "msgpack/object_fwd.hpp" 14 | 15 | 16 | namespace msgpack { 17 | 18 | /// @cond 19 | MSGPACK_API_VERSION_NAMESPACE(v2) { 20 | /// @endcond 21 | 22 | inline object::implicit_type object::convert() const 23 | { 24 | return v1::object::convert(); 25 | } 26 | 27 | /// @cond 28 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 29 | /// @endcond 30 | 31 | } // namespace msgpack 32 | 33 | #endif // MSGPACK_V2_OBJECT_HPP 34 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/object_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ static resolution routine 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_OBJECT_DECL_HPP 11 | #define MSGPACK_V2_OBJECT_DECL_HPP 12 | 13 | #include "msgpack/v1/object_decl.hpp" 14 | #include "msgpack/adaptor/adaptor_base.hpp" 15 | 16 | namespace msgpack { 17 | 18 | /// @cond 19 | MSGPACK_API_VERSION_NAMESPACE(v2) { 20 | /// @endcond 21 | 22 | using v1::object_handle; 23 | 24 | namespace detail { 25 | 26 | using v1::detail::add_ext_type_size; 27 | 28 | } // namespace detail 29 | 30 | using v1::aligned_zone_size; 31 | 32 | using v1::clone; 33 | 34 | namespace detail { 35 | 36 | using v1::detail::packer_serializer; 37 | 38 | } // namespace detail 39 | 40 | using v1::operator==; 41 | using v1::operator!=; 42 | 43 | /// @cond 44 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 45 | /// @endcond 46 | 47 | } // namespace msgpack 48 | 49 | #endif // MSGPACK_V2_OBJECT_DECL_HPP 50 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/pack_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ serializing routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_PACK_DECL_HPP 11 | #define MSGPACK_V2_PACK_DECL_HPP 12 | 13 | #include "msgpack/v1/pack_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | using v1::packer; 22 | 23 | using v1::pack; 24 | 25 | #if MSGPACK_ENDIAN_LITTLE_BYTE 26 | 27 | using v1::take8_8; 28 | 29 | using v1::take8_16; 30 | 31 | using v1::take8_32; 32 | 33 | using v1::take8_64; 34 | 35 | #elif MSGPACK_ENDIAN_BIG_BYTE 36 | 37 | using v1::take8_8; 38 | 39 | using v1::take8_16; 40 | 41 | using v1::take8_32; 42 | 43 | using v1::take8_64; 44 | 45 | #else 46 | #error msgpack-c supports only big endian and little endian 47 | #endif 48 | 49 | /// @cond 50 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 51 | /// @endcond 52 | 53 | } // namespace msgpack 54 | 55 | #endif // MSGPACK_V2_PACK_DECL_HPP 56 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/parse_return.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deserializing routine 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_PARSE_RETURN_HPP 11 | #define MSGPACK_V2_PARSE_RETURN_HPP 12 | 13 | #include "msgpack/v1/parse_return.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | 22 | // for internal use 23 | typedef enum { 24 | PARSE_SUCCESS = v1::PARSE_SUCCESS, 25 | PARSE_EXTRA_BYTES = v1::PARSE_EXTRA_BYTES, 26 | PARSE_CONTINUE = v1::PARSE_CONTINUE, 27 | PARSE_PARSE_ERROR = v1::PARSE_PARSE_ERROR, 28 | PARSE_STOP_VISITOR = -2 29 | } parse_return; 30 | 31 | /// @cond 32 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 33 | /// @endcond 34 | 35 | } // namespace msgpack 36 | 37 | #endif // MSGPACK_V2_PARSE_RETURN_HPP 38 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/sbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ simple buffer implementation 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_SBUFFER_DECL_HPP 11 | #define MSGPACK_V2_SBUFFER_DECL_HPP 12 | 13 | #include "msgpack/versioning.hpp" 14 | 15 | #ifndef MSGPACK_SBUFFER_INIT_SIZE 16 | #define MSGPACK_SBUFFER_INIT_SIZE 8192 17 | #endif 18 | 19 | namespace msgpack { 20 | 21 | /// @cond 22 | MSGPACK_API_VERSION_NAMESPACE(v2) { 23 | /// @endcond 24 | 25 | using v1::sbuffer; 26 | 27 | /// @cond 28 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 29 | /// @endcond 30 | 31 | } // namespace msgpack 32 | 33 | #endif // MSGPACK_V2_SBUFFER_DECL_HPP 34 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/vrefbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ zero-copy buffer implementation 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_VREFBUFFER_DECL_HPP 11 | #define MSGPACK_V2_VREFBUFFER_DECL_HPP 12 | 13 | #include "msgpack/v1/vrefbuffer_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | using v1::vrefbuffer; 22 | 23 | /// @cond 24 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 25 | /// @endcond 26 | 27 | } // namespace msgpack 28 | 29 | #endif // MSGPACK_V2_VREFBUFFER_DECL_HPP 30 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/zbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deflate buffer implementation 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_ZBUFFER_DECL_HPP 11 | #define MSGPACK_V2_ZBUFFER_DECL_HPP 12 | 13 | #include "msgpack/v1/zbuffer_decl.hpp" 14 | 15 | namespace msgpack { 16 | 17 | /// @cond 18 | MSGPACK_API_VERSION_NAMESPACE(v2) { 19 | /// @endcond 20 | 21 | using v1::zbuffer; 22 | 23 | /// @cond 24 | } // MSGPACK_API_VERSION_NAMESPACE(v2) 25 | /// @endcond 26 | 27 | } // namespace msgpack 28 | 29 | #endif // MSGPACK_V2_ZBUFFER_DECL_HPP 30 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/v2/zone_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ memory pool 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_V2_ZONE_DECL_HPP 11 | #define MSGPACK_V2_ZONE_DECL_HPP 12 | 13 | #include "msgpack/cpp_config.hpp" 14 | 15 | #if defined(MSGPACK_USE_CPP03) 16 | #include "msgpack/v2/detail/cpp03_zone_decl.hpp" 17 | #else // MSGPACK_USE_CPP03 18 | #include "msgpack/v2/detail/cpp11_zone_decl.hpp" 19 | #endif // MSGPACK_USE_CPP03 20 | 21 | #endif // MSGPACK_V2_ZONE_DECL_HPP 22 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * MessagePack for C version information 3 | * 4 | * Copyright (C) 2008-2009 FURUHASHI Sadayuki 5 | * 6 | * Distributed under the Boost Software License, Version 1.0. 7 | * (See accompanying file LICENSE_1_0.txt or copy at 8 | * http://www.boost.org/LICENSE_1_0.txt) 9 | */ 10 | #ifndef MSGPACK_VERSION_H 11 | #define MSGPACK_VERSION_H 12 | 13 | #ifdef __cplusplus 14 | extern "C" { 15 | #endif 16 | 17 | MSGPACK_DLLEXPORT 18 | const char* msgpack_version(void); 19 | MSGPACK_DLLEXPORT 20 | int msgpack_version_major(void); 21 | MSGPACK_DLLEXPORT 22 | int msgpack_version_minor(void); 23 | MSGPACK_DLLEXPORT 24 | int msgpack_version_revision(void); 25 | 26 | #include "version_master.h" 27 | 28 | #define MSGPACK_STR(v) #v 29 | #define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) 30 | 31 | #define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | 37 | #endif /* msgpack/version.h */ 38 | 39 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/version.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * MessagePack for C++ version information 3 | * 4 | * Copyright (C) 2008-2013 FURUHASHI Sadayuki and Takatoshi Kondo 5 | * 6 | * Distributed under the Boost Software License, Version 1.0. 7 | * (See accompanying file LICENSE_1_0.txt or copy at 8 | * http://www.boost.org/LICENSE_1_0.txt) 9 | */ 10 | #ifndef MSGPACK_VERSION_HPP 11 | #define MSGPACK_VERSION_HPP 12 | 13 | #include "version_master.h" 14 | 15 | #define MSGPACK_STR(v) #v 16 | #define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) 17 | 18 | #define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) 19 | 20 | inline const char* msgpack_version(void) { 21 | return MSGPACK_VERSION; 22 | } 23 | 24 | inline int msgpack_version_major(void) { 25 | return MSGPACK_VERSION_MAJOR; 26 | } 27 | 28 | inline int msgpack_version_minor(void) { 29 | return MSGPACK_VERSION_MINOR; 30 | } 31 | 32 | inline int msgpack_version_revision(void) { 33 | return MSGPACK_VERSION_REVISION; 34 | } 35 | 36 | #endif /* msgpack/version.hpp */ 37 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/version_master.h: -------------------------------------------------------------------------------- 1 | #define MSGPACK_VERSION_MAJOR 2 2 | #define MSGPACK_VERSION_MINOR 1 3 | #define MSGPACK_VERSION_REVISION 5 4 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/vrefbuffer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ zero-copy buffer implementation 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_VREFBUFFER_HPP 11 | #define MSGPACK_VREFBUFFER_HPP 12 | 13 | #include "msgpack/vrefbuffer_decl.hpp" 14 | 15 | #include "msgpack/v1/vrefbuffer.hpp" 16 | 17 | #endif // MSGPACK_VREFBUFFER_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/vrefbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ zero-copy buffer implementation 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_VREFBUFFER_DECL_HPP 11 | #define MSGPACK_VREFBUFFER_DECL_HPP 12 | 13 | #include "msgpack/v1/vrefbuffer_decl.hpp" 14 | #include "msgpack/v2/vrefbuffer_decl.hpp" 15 | 16 | #endif // MSGPACK_VREFBUFFER_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/zbuffer.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deflate buffer implementation 3 | // 4 | // Copyright (C) 2010-2013 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_ZBUFFER_HPP 11 | #define MSGPACK_ZBUFFER_HPP 12 | 13 | #include "msgpack/zbuffer_decl.hpp" 14 | 15 | #include "msgpack/v1/zbuffer.hpp" 16 | 17 | #endif // MSGPACK_ZBUFFER_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/zbuffer_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ deflate buffer implementation 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_ZBUFFER_DECL_HPP 11 | #define MSGPACK_ZBUFFER_DECL_HPP 12 | 13 | #include "msgpack/v1/zbuffer_decl.hpp" 14 | #include "msgpack/v2/zbuffer_decl.hpp" 15 | 16 | #endif // MSGPACK_ZBUFFER_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/zone.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ memory pool 3 | // 4 | // Copyright (C) 2008-2016 FURUHASHI Sadayuki and KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_ZONE_HPP 11 | #define MSGPACK_ZONE_HPP 12 | 13 | #include "msgpack/zone_decl.hpp" 14 | 15 | #include "msgpack/v1/zone.hpp" 16 | 17 | #endif // MSGPACK_ZONE_HPP 18 | -------------------------------------------------------------------------------- /include/third_party/msgpack/msgpack/zone_decl.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // MessagePack for C++ memory pool 3 | // 4 | // Copyright (C) 2016 KONDO Takatoshi 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | #ifndef MSGPACK_ZONE_DECL_HPP 11 | #define MSGPACK_ZONE_DECL_HPP 12 | 13 | #include "msgpack/v1/zone_decl.hpp" 14 | #include "msgpack/v2/zone_decl.hpp" 15 | 16 | #endif // MSGPACK_ZONE_DECL_HPP 17 | -------------------------------------------------------------------------------- /include/third_party/spdlog/details/log_msg.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2015 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | 12 | #include 13 | #include 14 | 15 | namespace spdlog 16 | { 17 | namespace details 18 | { 19 | struct log_msg 20 | { 21 | log_msg() = default; 22 | log_msg(const std::string *loggers_name, level::level_enum lvl) : logger_name(loggers_name), level(lvl) 23 | { 24 | #ifndef SPDLOG_NO_DATETIME 25 | time = os::now(); 26 | #endif 27 | 28 | #ifndef SPDLOG_NO_THREAD_ID 29 | thread_id = os::thread_id(); 30 | #endif 31 | } 32 | 33 | log_msg(const log_msg& other) = delete; 34 | log_msg& operator=(log_msg&& other) = delete; 35 | log_msg(log_msg&& other) = delete; 36 | 37 | 38 | const std::string *logger_name; 39 | level::level_enum level; 40 | log_clock::time_point time; 41 | size_t thread_id; 42 | fmt::MemoryWriter raw; 43 | fmt::MemoryWriter formatted; 44 | }; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /include/third_party/spdlog/details/null_mutex.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2015 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | // null, no cost dummy "mutex" and dummy "atomic" int 10 | 11 | namespace spdlog 12 | { 13 | namespace details 14 | { 15 | struct null_mutex 16 | { 17 | void lock() {} 18 | void unlock() {} 19 | bool try_lock() 20 | { 21 | return true; 22 | } 23 | }; 24 | 25 | struct null_atomic_int 26 | { 27 | int value; 28 | null_atomic_int() = default; 29 | 30 | null_atomic_int(int val):value(val) 31 | {} 32 | 33 | int load(std::memory_order) const 34 | { 35 | return value; 36 | } 37 | 38 | void store(int val) 39 | { 40 | value = val; 41 | } 42 | }; 43 | 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /include/third_party/spdlog/fmt/bundled/ostream.cc: -------------------------------------------------------------------------------- 1 | /* 2 | Formatting library for C++ - std::ostream support 3 | 4 | Copyright (c) 2012 - 2016, Victor Zverovich 5 | All rights reserved. 6 | 7 | For the license information refer to format.h. 8 | */ 9 | 10 | #include "ostream.h" 11 | 12 | namespace fmt { 13 | 14 | namespace internal { 15 | FMT_FUNC void write(std::ostream &os, Writer &w) 16 | { 17 | const char *data = w.data(); 18 | typedef internal::MakeUnsigned::Type UnsignedStreamSize; 19 | UnsignedStreamSize size = w.size(); 20 | UnsignedStreamSize max_size = 21 | internal::to_unsigned((std::numeric_limits::max)()); 22 | do { 23 | UnsignedStreamSize n = size <= max_size ? size : max_size; 24 | os.write(data, static_cast(n)); 25 | data += n; 26 | size -= n; 27 | } while (size != 0); 28 | } 29 | } 30 | 31 | FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) 32 | { 33 | MemoryWriter w; 34 | w.write(format_str, args); 35 | internal::write(os, w); 36 | } 37 | } // namespace fmt 38 | -------------------------------------------------------------------------------- /include/third_party/spdlog/fmt/fmt.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | // 9 | // Include a bundled header-only copy of fmtlib or an external one. 10 | // By default spdlog include its own copy. 11 | // 12 | 13 | #if !defined(SPDLOG_FMT_EXTERNAL) 14 | 15 | #ifndef FMT_HEADER_ONLY 16 | #define FMT_HEADER_ONLY 17 | #endif 18 | #ifndef FMT_USE_WINDOWS_H 19 | #define FMT_USE_WINDOWS_H 0 20 | #endif 21 | #include 22 | 23 | #else //external fmtlib 24 | 25 | #include 26 | 27 | #endif 28 | 29 | -------------------------------------------------------------------------------- /include/third_party/spdlog/fmt/ostr.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | // include external or bundled copy of fmtlib's ostream support 9 | // 10 | #if !defined(SPDLOG_FMT_EXTERNAL) 11 | #include 12 | #include 13 | #else 14 | #include 15 | #endif 16 | 17 | 18 | -------------------------------------------------------------------------------- /include/third_party/spdlog/formatter.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2015 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | 10 | #include 11 | #include 12 | #include 13 | 14 | namespace spdlog 15 | { 16 | namespace details 17 | { 18 | class flag_formatter; 19 | } 20 | 21 | class formatter 22 | { 23 | public: 24 | virtual ~formatter() {} 25 | virtual void format(details::log_msg& msg) = 0; 26 | }; 27 | 28 | class pattern_formatter : public formatter 29 | { 30 | 31 | public: 32 | explicit pattern_formatter(const std::string& pattern); 33 | pattern_formatter(const pattern_formatter&) = delete; 34 | pattern_formatter& operator=(const pattern_formatter&) = delete; 35 | void format(details::log_msg& msg) override; 36 | private: 37 | const std::string _pattern; 38 | std::vector> _formatters; 39 | void handle_flag(char flag); 40 | void compile_pattern(const std::string& pattern); 41 | }; 42 | } 43 | 44 | #include 45 | 46 | -------------------------------------------------------------------------------- /include/third_party/spdlog/sinks/base_sink.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2015 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | // 8 | // base sink templated over a mutex (either dummy or realy) 9 | // concrete implementation should only overrid the _sink_it method. 10 | // all locking is taken care of here so no locking needed by the implementers.. 11 | // 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #include 19 | 20 | namespace spdlog 21 | { 22 | namespace sinks 23 | { 24 | template 25 | class base_sink:public sink 26 | { 27 | public: 28 | base_sink():_mutex() {} 29 | virtual ~base_sink() = default; 30 | 31 | base_sink(const base_sink&) = delete; 32 | base_sink& operator=(const base_sink&) = delete; 33 | 34 | void log(const details::log_msg& msg) override 35 | { 36 | std::lock_guard lock(_mutex); 37 | _sink_it(msg); 38 | } 39 | 40 | protected: 41 | virtual void _sink_it(const details::log_msg& msg) = 0; 42 | Mutex _mutex; 43 | }; 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /include/third_party/spdlog/sinks/msvc_sink.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Alexander Dalshov. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | #if defined(_MSC_VER) 9 | 10 | #include 11 | #include 12 | 13 | #include 14 | 15 | #include 16 | #include 17 | 18 | namespace spdlog 19 | { 20 | namespace sinks 21 | { 22 | /* 23 | * MSVC sink (logging using OutputDebugStringA) 24 | */ 25 | template 26 | class msvc_sink : public base_sink < Mutex > 27 | { 28 | public: 29 | explicit msvc_sink() 30 | { 31 | } 32 | 33 | void flush() override 34 | { 35 | } 36 | 37 | protected: 38 | void _sink_it(const details::log_msg& msg) override 39 | { 40 | OutputDebugStringA(msg.formatted.c_str()); 41 | } 42 | }; 43 | 44 | typedef msvc_sink msvc_sink_mt; 45 | typedef msvc_sink msvc_sink_st; 46 | 47 | } 48 | } 49 | 50 | #endif 51 | -------------------------------------------------------------------------------- /include/third_party/spdlog/sinks/null_sink.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2015 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | 11 | #include 12 | 13 | namespace spdlog 14 | { 15 | namespace sinks 16 | { 17 | 18 | template 19 | class null_sink : public base_sink < Mutex > 20 | { 21 | protected: 22 | void _sink_it(const details::log_msg&) override 23 | {} 24 | 25 | void flush() override 26 | {} 27 | 28 | }; 29 | typedef null_sink null_sink_st; 30 | typedef null_sink null_sink_mt; 31 | 32 | } 33 | } 34 | 35 | -------------------------------------------------------------------------------- /include/third_party/spdlog/sinks/sink.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2015 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | 7 | #pragma once 8 | 9 | #include 10 | 11 | namespace spdlog 12 | { 13 | namespace sinks 14 | { 15 | class sink 16 | { 17 | public: 18 | sink() 19 | { 20 | _level = level::trace; 21 | } 22 | 23 | virtual ~sink() {} 24 | virtual void log(const details::log_msg& msg) = 0; 25 | virtual void flush() = 0; 26 | 27 | bool should_log(level::level_enum msg_level) const; 28 | void set_level(level::level_enum log_level); 29 | level::level_enum level() const; 30 | 31 | private: 32 | level_t _level; 33 | 34 | }; 35 | 36 | inline bool sink::should_log(level::level_enum msg_level) const 37 | { 38 | return msg_level >= _level.load(std::memory_order_relaxed); 39 | } 40 | 41 | inline void sink::set_level(level::level_enum log_level) 42 | { 43 | _level.store(log_level); 44 | } 45 | 46 | inline level::level_enum sink::level() const 47 | { 48 | return static_cast(_level.load(std::memory_order_relaxed)); 49 | } 50 | 51 | } 52 | } 53 | 54 | -------------------------------------------------------------------------------- /src/QueryExample.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include "blib/bun/bun.hpp" 9 | 10 | // BOOST_PROTO_MAX_LOGICAL_ARITY 11 | using namespace boost; 12 | namespace test { 13 | struct Person { 14 | std::string name; 15 | int age; 16 | float height; 17 | }; 18 | } 19 | 20 | int main1() { 21 | auto p = proto::as_expr( std::string( "10" ) ); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /vs/bun/bun.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | $(OutDir) 5 | WindowsLocalDebugger 6 | 7 | 8 | $(OutDir) 9 | WindowsLocalDebugger 10 | 11 | --------------------------------------------------------------------------------