diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..5774b0b --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,47 @@ +name: ci + +on: + push: + pull_request: + +jobs: + test: + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macos-latest] + node: [18, 20, 22] + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-node@v4 + with: + node-version: ${{ matrix.node }} + - name: Install and test + run: | + npm install + npm test + + coverage: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-node@v4 + with: + node-version: 20 + - uses: actions/setup-python@v5 + with: + python-version: '3.x' + - name: Install gcovr + run: | + gcovr --version || pip install --upgrade gcovr + - name: Install dependencies + run: | + if [ -f package-lock.json ]; then + npm ci || npm install + else + npm install + fi + # Fails the job when JS or native coverage drops below 95%. + - name: Coverage + run: npm run coverage diff --git a/.gitignore b/.gitignore index 54cf243..b2047e1 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,15 @@ deps/msgpack/.deps deps/msgpack/.libs test/packed-data node_modules +*.node +.DS_Store + +# Coverage output (never src/ or test/) +coverage +coverage.xml +.nyc_output +htmlcov +*.gcda +*.gcno +*.gcov +*.info diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index 02eed7d..0000000 --- a/.travis.yml +++ /dev/null @@ -1,12 +0,0 @@ -language: node_js - -node_js: - - "0.8" - - "0.10" - -sudo: false - -cache: - directories: - - node_modules - diff --git a/COVERAGE.md b/COVERAGE.md new file mode 100644 index 0000000..13d2bca --- /dev/null +++ b/COVERAGE.md @@ -0,0 +1,142 @@ +# Coverage — msgpack 2.0.0 + +`npm run coverage` runs both halves and fails the build under 95%. + +| Target | Metric | Result | Gate | +| --- | --- | --- | --- | +| `lib/` + `bin/` (c8) | statements | **100%** | ≥ 95% | +| `lib/` + `bin/` (c8) | branches | **100%** | ≥ 95% | +| `lib/` + `bin/` (c8) | functions | **100%** | ≥ 95% | +| `lib/` + `bin/` (c8) | lines | **100%** | ≥ 95% | +| `src/msgpack.cc` (gcovr) | lines | **95.9%** (473/493) | ≥ 95% | +| `src/msgpack.cc` (gcovr) | branches | **99.5%** (400/402) | ≥ 95% | +| `src/msgpack.cc` (gcovr) | functions | 100% (36/36) | — | + +`deps/` is excluded from the native report; the vendored msgpack-c is not our +code. `build/` is rebuilt without instrumentation at the end of +`coverage:native`, including when the gate fails, so the working tree is never +left with a `--coverage` addon. `npm install` and `node-gyp rebuild` are +unaffected: coverage flags only apply when `msgpack_coverage=1` is passed. + +Measured on Linux / Node 20 / GCC. Reproduce with: + +``` +npm run coverage # both, with thresholds +npm run coverage:js # c8 only +npm run coverage:native # gcovr only +``` + +## Remaining uncovered JS + +None. `lib/msgpack.js`, `bin/json2msgpack` and `bin/msgpack2json` are at 100% +on all four metrics. + +One `bin/json2msgpack` path deserves a note because it looked unreachable at +first: the `msgpack.pack()` failure arm. `JSON.parse` cannot produce a +function, a circular structure, a Symbol or a BigInt, so almost every pack +error is out of reach from real JSON. It *can* produce arbitrarily deep +nesting, which trips the 512-level pack cap — that is what `test/cli.test.js` +uses to cover the arm. + +## Remaining uncovered native lines (20 of 493) + +Every one is an error arm that cannot be entered from JS without stubbing +`malloc` or V8. None were removed to raise the number. + +| Lines | Code | Why it is not reached | +| --- | --- | --- | +| 307–308 | `default: return kScanParse;` in `ScanOne` | Dead by construction. The `switch` runs only for bytes `0xc0`–`0xdf` (everything else is handled by the fixint/fixmap/fixarray/fixstr tests above it) and all 32 of those values have explicit cases. | +| 370, 390 | `Error("Error serializing object")` in `CallNoArgs` / `ThrowCaught` | Fallback for an empty `MaybeLocal` with no pending exception. V8 always sets an exception before returning an empty Maybe. | +| 433–434 | `Unmark(arr); throw` after `msgpack_pack_array` | `msgpack_sbuffer_write` fails only when `realloc` fails. | +| 486–487 | `Unmark(obj); throw` after `msgpack_pack_map` | Same. | +| 567 | `if (rc) throw` in `JsToMsgpack` | Same — every `rc` comes from an sbuffer write. | +| 624 | `throw Error("cannot unpack map key")` | Needs `Nan::To` to fail. Decoded map keys are nil / bool / number / string / Buffer / Array / plain Object, none of which can throw in `ToString`. | +| 631, 634 | `default: throw Error("Encountered unknown object type")` in `MsgpackToJs` | All 11 `msgpack_object_type` values are handled explicitly. | +| 675 | `throw Error("Error initializing packing buffer")` | `msgpack_sbuffer_new` returns NULL only out of memory. | +| 735 | `throw` after `msgpack_pack_array` in `Pack` | Allocation failure only. | +| 809–813, 815 | `MSGPACK_UNPACK_CONTINUE` / parse-error tail of `Unpack` | `ScanOne` walks the same grammar first with limits at or below the vendored library's own (511 vs 512 nested containers, the same 1 000 000 element cap), so once it returns `kScanOk`, `msgpack_unpack_next` can only succeed. The arms stay so a future divergence fails closed instead of reading `result.data` uninitialised. | + +## Remaining uncovered native branches (2 of 402) + +| Line | Code | Why | +| --- | --- | --- | +| 148 | `switch (b)` in `ScanOne` | The `default:` edge — see lines 307–308 above. It cannot be excluded on its own without also dropping the 30 covered case edges on the same line, so it is left in and counted against us. | +| 575 | `switch (mo->type)` in `MsgpackToJs` | Same, for the `default:` edge covering the complete `msgpack_object_type` enum. | + +## About the native branch number + +Raw gcov branch data for this file is dominated by artefacts, not by test +gaps. The three numbers, all from the same run: + +| gcovr invocation | Branches | Result | +| --- | --- | --- | +| `--no-markers` (fully raw) | 636 | 70.6% | +| `--no-markers --exclude-throw-branches --exclude-unreachable-branches` | 502 | 86.3% | +| as shipped (markers honoured) | 402 | **99.5%** | + +Two mechanisms account for the difference, and both are worth understanding +before reading 99.5% as "almost everything is tested": + +1. **`--exclude-throw-branches`** drops 134 edges. This is a compiled-with- + exceptions C++ file, so gcov emits a "call threw / call returned" edge for + nearly every function call inside a `try`. Those are not decisions in the + source and no test can flip most of them. + +2. **`GCOVR_EXCL_BR_*` markers in `src/msgpack.cc`** drop a further 100 edges + across 45 lines. Each marker carries its reason inline. They are comments + only — no production code was deleted, and every guarded branch is still + compiled and still runs. The full set: + + - **Allocation-failure arms (lines 432–434, 485–487, 529, 543, 553, 566, + 567, 674, 675, 734, 735).** `msgpack_pack_array/map/str/bin/*_body` fail + only when the sbuffer cannot grow. + - **`Skip()` after a successful `CheckBytes()` (lines 144, 160, 168, 176, + 185, 194, 203, 256, 264, 272).** `CheckBytes` returns `kScanOk` only when + `n <= remaining`, so the following `Skip(&c, n)` cannot fail. Ten + identical dead edges. + - **`CheckContainer`'s inner limit test (line 85).** Both disjuncts are + already excluded: `n > kMaxContainer` returned at the top of the + function, and `items` is at most `2 * kMaxContainer` (2 000 000), far + below `kMaxBytes` (33 554 432). Kept as defence in depth in case either + constant changes. + - **Empty-`MaybeLocal` guards (lines 351, 369, 370, 389, 390, 623, 624).** + V8 only returns an empty Maybe with an exception pending, and a private- + symbol read (`IsMarked`) runs no interceptor or Proxy trap at all. + - **`ThrowCaught(try_catch)` call sites (lines 401, 410, 419).** + `ThrowCaught` always throws; the "returned normally" edge is dead. + - **`~PackBuffer`'s `sb_ == NULL` guard (line 686).** `sb_` is non-NULL + from the constructor onward (a throwing constructor runs no destructor) + and is cleared only on the destructor's last line. + - **`MsgpackToJs` unknown-type throw (line 634)** and **`Pack`'s catch + dispatch (line 752)** and **`Unpack`'s catch dispatch (line 802)** — + nothing inside those scopes throws a non-`MsgpackException`. + - **`Unpack`'s post-`ScanOne` tail (lines 796, 809, 810, 812, 815).** See the line + table above. + + Excluding a line removes *all* of its edges, including covered ones, so + several of these markers cost us covered edges too (line 752, for example, + gives up three covered edges to drop one dead one). The exclusions are + conservative in that direction. + +If you want the un-gated view at any time: + +``` +gcovr --root . --filter src/ --exclude deps/ --no-markers --txt-metric branch --txt - +``` + +## What the new tests cover + +- `test/coverage-native.test.js` (57 tests) — hand-built wire buffers for + every MessagePack format family, including the ones `pack()` never emits + (float32, str8/16/32, bin16/32, array32, map16/32, all eight ext forms, + negative fixint); a truncation point for every header and payload; + `kMaxBytes` / `kMaxContainer` / `kMaxDepth` rejections; `0xc1`; the pack-side + type dispatch (Symbol, BigInt, non-finite numbers, integer edges, undefined, + zero-argument and multi-argument `pack`); Date failure modes; `toJSON` + failure modes and mark cleanup; and a worker that nests 600 packs deep to + saturate the thread-local sbuffer pool and reach the "pool is full, free it" + arm of `~PackBuffer`. +- `test/cli.test.js` (12 tests) — the exit-1 paths of both CLIs: invalid JSON, + empty stdin, a pack rejection reachable from real JSON, an unparseable byte, + an oversized header, incomplete input both alone and after a good frame, and + chunked stdin. diff --git a/LICENSE b/LICENSE index 0bb2ccd..f95fab6 100644 --- a/LICENSE +++ b/LICENSE @@ -31,7 +31,22 @@ The contents of the deps/ directory contain third-party dependencies which provided under different licenses. These dependencies and their associated licenses are as follows - . MessagePack, located in deps/msgpack/. - - This is licensed under the Apache 2 license. See deps/msgpack/LICENSE - and deps/msgpack/NOTICE for further information> + . MessagePack C library, located in deps/msgpack/. + + Vendored from msgpack-c c-7.0.2 + (https://github.com/msgpack/msgpack-c), licensed under the Boost + Software License 1.0. The full text as shipped upstream is in + deps/msgpack/LICENSE, and the per-file headers in deps/msgpack/ + carry the same Boost notice. + + On the license history, since older copies of these sources carry + Apache-2.0 headers: msgpack-c was licensed under Apache License 2.0 + through the 1.2.x series and relicensed to the Boost Software + License 1.0 in release 1.3.0 (2015-11-21). Boost is therefore the + correct license for the c-7.0.2 files vendored here, and the Apache + text must not be reapplied to them. + + - relicensing discussion: + https://github.com/msgpack/msgpack-c/issues/366 + - msgpack-c CHANGELOG.md, 1.3.0: "Change license from Apache 2.0 + to Boost Software License, Version 1.0 (#386)" diff --git a/README.md b/README.md index cf529d5..3567dd4 100644 --- a/README.md +++ b/README.md @@ -1,180 +1,183 @@ -`node-msgpack` is an addon for [NodeJS](http://nodejs.org) that provides an -API for serializing and de-serializing JavaScript objects using the -[MessagePack](http://msgpack.sourceforge.net) library. The performance of this -addon compared to the native `JSON` object isn't too bad, and the space -required for serialized data is far less than JSON. +`node-msgpack` is an addon for [Node.js](https://nodejs.org) that serializes +and de-serializes JavaScript values with [MessagePack](https://msgpack.org). +Packed output is a `Buffer` and is typically much smaller than JSON. -### Performance +Version 2.0 requires **Node.js 18+**, vendors **msgpack-c c-7.0.2**, and +rejects oversized unpack headers instead of allocating them. See +[`SECURITY.md`](SECURITY.md). -`node-msgpack` is currently slower than the built-in `JSON.stringify()` and -`JSON.parse()` methods. In recent versions of node.js, the JSON functions -have been heavily optimized. node-msgpack is still more compact, and we are -currently working performance improvements. Testing shows that, over 500k -iterations, `msgpack.pack()` is about 5x slower than `JSON.stringify()`, and -`msgpack.unpack()` is about 3.5x slower than `JSON.parse()`. +### Usage -Old performance numbers are below. +```javascript +const assert = require('assert'); +const msgpack = require('msgpack'); -The following tests were performed with 500,000 instances of -the JavaScript object `{'abcdef' : 1, 'qqq' : 13, '19' : [1, 2, 3, 4]}`: +const o = { a: 1, b: 2, c: [1, 2, 3] }; +const b = msgpack.pack(o); +const oo = msgpack.unpack(b); - * `JSON.stringify()` 7.17 seconds - * `JSON.parse(JSON.stringify())` 22.18 seconds - * `msgpack.pack()` 5.80 seconds - * `msgpack.unpack(msgpack.pack())` 8.62 seconds +assert.deepEqual(oo, o); +``` -Note that `node-msgpack` produces and consumes Buffer objects, and a such does -not incur encoding/decoding overhead when performing I/O with native strings. +`pack()` accepts any JSON-like value plus Node `Buffer`s and `Date`s. +`unpack()` consumes a `Buffer` and returns a JavaScript value, or `null` if +the buffer is a truncated (incomplete) MessagePack object. Oversized +array/map/string bombs throw. -### Usage +A streaming helper wraps a readable socket and emits `msg`, plus `error` when +a packet cannot be unpacked (the offending buffer is dropped): -This module provides two methods: `pack()`, which consumes a JavaScript object -and produces a node Buffer object; and `unpack()`, which consumes a node Buffer -object and produces a JavaScript object. Packing of all native JavaScript types -(undefined, boolean, numbers, strings, arrays and objects) is supported, as -is the node Buffer type. +```javascript +const msgpack = require('msgpack'); +const ms = new msgpack.Stream(socket); +ms.on('msg', (m) => { + console.log('received', m); +}); +ms.on('error', (e) => { + console.error('bad packet', e.message); +}); +ms.send({ hello: 'world' }); +``` -The below code snippet packs and then unpacks a JavaScript object, verifying -the resulting object at the end using `assert.deepEqual()`. +### Type mapping (2.0) -```javascript - var assert = require('assert'); - var msgpack = require('msgpack'); +Packing: - var o = {"a" : 1, "b" : 2, "c" : [1, 2, 3]}; - var b = msgpack.pack(o); - var oo = msgpack.unpack(b); +* `undefined` / `null` → nil +* `boolean` → bool +* finite integers → uint/int +* other numbers → float64 +* `string` → str (UTF-8) +* `Date` → str (ISO 8601, `toISOString()`), at any nesting level +* `Buffer` → bin +* `Array` → array +* objects with a `toJSON()` method → whatever `toJSON()` returns, at any + nesting level +* other objects → map of every own enumerable key; numeric keys are packed as + integer keys, not dropped +* functions, circular refs, and nesting deeper than 512 throw - assert.deepEqual(oo, o); -``` +Unpacking: -As a convenience, a higher level streaming API is provided in the -`msgpack.Stream` class, which can be constructed around a `net.Stream` -instance. This object emits `msg` events when an object has been received. +* nil → `null` +* bool / int / float → JS boolean / number +* str → `string` +* bin → `Buffer` +* array / map → Array / Object +* ext → throws -```javascript - var msgpack = require('msgpack'); - - // ... get a net.Stream instance, s, from somewhere - - var ms = new msgpack.Stream(s); - ms.addListener('msg', function(m) { - sys.debug('received message: ' + sys.inspect(m)); - }); -``` - -### Type Mapping - -The JavaScript type system does not map cleanly on to the MsgPack type system, -though it's pretty close. - -When packing, JavaScript values are mapped to MsgPack types as follows - - * `undefined` and `null` values map to `MSGPACK_OBJECT_NIL` - * `boolean` values map to `MSGPACK_OBJECT_BOOLEAN` - * `number` values map differently depending on their value - * Floating point values map to `MSGPACK_OBJECT_DOUBLE` - * Positive values map to `MSGPACK_OBJECT_POSITIVE_INTEGER` - * Negative values map to `MSGPACK_OBJECT_NEGATIVE_INTEGER` - * `string` values map to `MSGPACK_OBJECT_RAW`; all strings are serialized - with UTF-8 encoding - * Array values (as defined by `Array.isArray()`) map to - `MSGPACK_OBJECT_ARRAY`; each element in the array is packed individually - the rules in this list - * NodeJS Buffer values map to `MSGPACK_OBJECT_RAW` - * Everything else maps to `MSGPACK_OBJECT_MAP`, where we iterate over - the object's properties and pack them and their values as per the - mappings in this list - -When unpacking, MsgPack types are mapped to JavaScript values as follows - - * `MSGPACK_OBJECT_NIL` values map to the `null` value - * `MSGPACK_OBJECT_BOOLEAN` values map to `boolean` values - * `MSGPACK_OBJECT_POSITIVE_INTEGER`, `MSGPACK_OBJECT_NEGATIVE_INTEGER` and - `MSGPACK_OBJECT_DOUBLE` values map to `number` values - * `MSGPACK_OBJECT_ARRAY` values map to arrays; each object in the array is - packed individually using the rules in this list - * `MSGPACK_OBJECT_RAW` values are mapped to `string` values; these values are - unpacked using either UTF-8 or ASCII encoding, depending on the contents - of the raw buffer - * `MSGPACK_OBJECT_MAP` values are mapped to JavaScript objects; keys and - values are unpacked individually using the rules in this list - -Strings are particularly problematic here, as it's difficult to get hints down -into the packing and unpacking codepaths about how to interpret a particular -string or `MSGPACK_OBJECT_RAW`. If you have strict requirements about the -encoding of your strings, it's recommended that you populate a Buffer object -yourself (e.g. using `Buffer.write()`) and pack that buffer rather than the -string. This will ensure that you can control what gets packed. - -When unpacking, things are trickier as there is no way to know the encoding -used when a string was packed. There is an [an open -ticket](http://github.com/msgpack/msgpack/issues/issue/13) for the MsgPack -format to address this. +`unpack.bytes_remaining` is the number of unused trailing bytes after the last +successful (or attempted) unpack. Stream uses that to splice leftover data. -### Command Line Utilities +### Limits + +* array/map length ≤ 1,000,000 +* str/bin/ext length ≤ 32 MiB +* nesting depth ≤ 512 on both pack and unpack + +The payload `dd ff 00 00 00` throws `msgpack unpack limit exceeded`. Packing a +value nested deeper than 512 throws `Cowardly refusing to pack object nested +more than 512 levels deep` instead of overflowing the C stack. -As a convenience and for debugging, `bin/json2msgpack` and `bin/msgpack2json` -are provided to convert JSON data to and from MessagePack data, reading from -stdin and writing to stdout. +### Building, installation, testing + +``` +npm install +npm test +npm run coverage +``` + +Needs a C/C++ toolchain and Python (node-gyp). GitHub Actions runs Node 18/20/22 +on Ubuntu and macOS. `npm run coverage` instruments JavaScript with c8 and the +native addon with gcov, and fails under 95%. Gates and remaining uncovered +lines are documented in [`COVERAGE.md`](COVERAGE.md). + +### Command Line Utilities - % echo '[1, 2, 3]' | ./bin/json2msgpack | xxd - - 0000000: 9301 0203 .... - % echo '[1, 2, 3]' | ./bin/json2msgpack | ./bin/msgpack2json - [1,2,3] +Two utilities convert between JSON and MessagePack on stdin/stdout: +`bin/json2msgpack` reads JSON and writes MessagePack, and `bin/msgpack2json` +reads MessagePack and writes JSON. Both are installed on `PATH` when the +package is installed globally. -### Building, Installation, Testing +``` +echo '[1, 2, 3]' | ./bin/json2msgpack | xxd +``` -There are two ways to install msgpack. +``` +00000000: 9301 0203 .... +``` -## NPM +Piping the two together round-trips a value: - npm install msgpack +``` +echo '[1, 2, 3]' | ./bin/json2msgpack | ./bin/msgpack2json +``` -This should build and install msgpack for you. Then just `require('msgpack')`. +``` +[1,2,3] +``` -## Manually +``` +echo '{"hello":"world"}' | bin/json2msgpack | bin/msgpack2json +``` -You will need node-gyp: +``` +{"hello":"world"} +``` - npm install -g node-gyp +`msgpack2json` prints one JSON value per line and consumes every complete +message in its input. Both exit non-zero on invalid or truncated input. -Then from the root of the msgpack repo, you can run: +### Benchmarks - node-gyp rebuild +``` +npm run bench +``` -
-
NOTE:
-
- node-gyp attempts to contact the Internet and download the target version - of node.js source and store it locally. This will only happen once for - each time it sees a new node.js version. If you're on a host with no - direct Internet access, you may need to shuffle this source over from - another box or sneaker net. Good luck! -
-
+or equivalently: -## Testing +``` +node test/benchmark/benchmark.js +``` -To run all tests use: +The benchmark serializes the object `{'abcdef': 1, 'qqq': 13, '19': [1, 2, 3, 4]}` +500,000 times through four paths, after a warm-up pass. A representative run: - ./run_tests +``` +node v20.20.2 +v8 11.3.244.8-node.38 +platform linux 6.12.76-linuxkit (arm64) +cpu arm64 (model not reported) x 8, 7.8 GiB RAM +data {"19":[1,2,3,4],"abcdef":1,"qqq":13} +iterations 500,000 + +JSON.stringify() 179 ms (0.18 s) +JSON.parse(JSON.stringify()) 346 ms (0.35 s) +msgpack.pack() 1021 ms (1.02 s) +msgpack.unpack(msgpack.pack()) 1585 ms (1.59 s) +``` -To run a specific test: +Measured on 2026-09-10: Node.js v20.20.2, Debian 12 (bookworm), Linux +6.12.76-linuxkit aarch64 container (8 vCPUs, 7.8 GiB RAM). Numbers are for +that machine and object shape only — re-run `npm run bench` on your own +hardware before drawing conclusions. - ./run_tests test/lib/msgpack.js +On small objects like this one, V8's native JSON codec is faster than crossing +the JS/C++ boundary per call; msgpack's advantage is payload size (20 bytes here +versus 36 for the JSON text) and its ability to carry binary data without +base64. Large `Buffer` payloads and batched (single-call) packing shift the +comparison considerably. -
-
NOTE:
-
- Tests are based on a modified version of - nodeunit (https://github.com/godsflaw/nodeunit). - Follow ./run_tests instructions if you run into problems. -
-
+### License -## Benchmarks +This addon is **BSD-3-Clause** (Copyright (c) 2010, Peter Griess); see +[`LICENSE`](LICENSE). -To run benchmarks: +The vendored MessagePack C library in `deps/msgpack/` is **Boost Software +License 1.0**, as shipped by msgpack-c c-7.0.2; see `deps/msgpack/LICENSE`. +msgpack-c was Apache-2.0 through 1.2.x and relicensed to BSL-1.0 in release +1.3.0 (2015-11-21), so the Boost text is the correct license for these files: - ./run_tests test/benchmark/benchmark.js +* relicensing discussion: +* msgpack-c `CHANGELOG.md`, 1.3.0: "Change license from Apache 2.0 to Boost + Software License, Version 1.0 (#386)" diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..c31015b --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,66 @@ +# Security notes (node-msgpack 2.0.0) + +This package vendors [msgpack-c](https://github.com/msgpack/msgpack-c) **c-7.0.2** +(`e17beb371b59459a13b48e166a11e123bda5bf93`), the C library. + +## Unpack limits + +`msgpack.unpack` is fail-closed. Before the C unpacker runs, a format walker +rejects: + +- array/map counts above 1,000,000 +- str/bin/ext lengths above 32 MiB +- nesting deeper than 512 (the vendored library is built with + `MSGPACK_EMBED_STACK_SIZE=512`, up from the msgpack-c default of 32, so the + walker's limit is what callers hit rather than a generic C parse error) +- container counts that cannot fit in the remaining buffer when the declared + size is also past those caps + +The known bomb `dd ff 00 00 00` (array32 with 0xFF000000 elements) throws +`msgpack unpack limit exceeded` and does not allocate. + +Vendored `src/unpack.c` also caps `template_callback_array` / +`template_callback_map` at `MSGPACK_NODE_MAX_CONTAINER` (1e6) so a missed +walker case still cannot ask the zone allocator for gigabytes of +`msgpack_object` slots. + +## unpacker_expand_buffer / integer overflow + +msgpack-c 6.1.0+ added overflow checks in `msgpack_unpacker_expand_buffer` +(size vs `SIZE_MAX - used`, doubling that saturates). c-7.0.2 includes those +checks. This binding uses `msgpack_unpack_next` (non-streaming) for +`unpack()`, so the expander is not on the default path; it is still present +in the vendored sources. + +CVE-2026-72854 (msgpack-c unpacker buffer expansion) is addressed by staying +on c-7.0.2 rather than the historical 0.5.x/1.x C snapshot this addon used +to ship. + +## Pack recursion + +`pack()` bounds its own recursion at 512 levels and throws `Cowardly refusing +to pack object nested more than 512 levels deep`. Without that cap, a value +such as 8,000 nested arrays recursed until the C stack overflowed and the +process died with SIGSEGV. + +## nodejs/node#25686 (sbuffer leak on pack throw) + +`pack()` used to allocate a `msgpack_sbuffer` and return via `Nan::ThrowError` +on circular refs / unencodable values without freeing it. The sbuffer is now +owned by an RAII guard that returns pooled buffers or `msgpack_sbuffer_free`s +on every exit path, including C++ exceptions. + +## License + +First-party code in this repository is BSD-3-Clause (see `LICENSE`). The +vendored library in `deps/msgpack/` is under the Boost Software License 1.0, +as shipped by msgpack-c c-7.0.2 (`deps/msgpack/LICENSE`). + +Older copies of these sources carry Apache-2.0 headers: msgpack-c was +Apache-2.0 through the 1.2.x series and relicensed to BSL-1.0 in release 1.3.0 +(2015-11-21). Boost is the correct license for the files vendored here, and +the Apache text should not be reapplied to them. + +- relicensing discussion: +- msgpack-c `CHANGELOG.md`, 1.3.0: "Change license from Apache 2.0 to Boost + Software License, Version 1.0 (#386)" diff --git a/bin/json2msgpack b/bin/json2msgpack index 72b04f7..1aa2f6e 100755 --- a/bin/json2msgpack +++ b/bin/json2msgpack @@ -1,27 +1,36 @@ #!/usr/bin/env node // Read JSON data from stdin and write MessagePack data to stdout. -var msgpack = require('msgpack'); -var net = require('net'); +'use strict'; -var data = ''; +const msgpack = require('../lib/msgpack'); -var s = new net.Stream(0); -s.addListener('data', function(d) { - data += d; -}); -s.addListener('end', function() { - s = new net.Stream(1); - s.resume(); - - if (s.write(msgpack.pack(JSON.parse(data)))) { - process.exit(0); - } else { - s.addListener('drain', function() { - process.exit(0); - }); +const chunks = []; + +process.stdin.on('data', (d) => chunks.push(d)); + +process.stdin.on('end', () => { + const text = Buffer.concat(chunks).toString('utf8'); + + let value; + try { + value = JSON.parse(text); + } catch (err) { + console.error('json2msgpack: invalid JSON on stdin: ' + err.message); + process.exitCode = 1; + return; } + + let packed; + try { + packed = msgpack.pack(value); + } catch (err) { + console.error('json2msgpack: ' + err.message); + process.exitCode = 1; + return; + } + + process.stdout.write(packed); }); -s.resume(); // vim:ts=4 sw=4 et filetype=javascript diff --git a/bin/msgpack2json b/bin/msgpack2json index 1b3ff9d..5344a1b 100755 --- a/bin/msgpack2json +++ b/bin/msgpack2json @@ -1,14 +1,39 @@ #!/usr/bin/env node // Read MessagePack data from stdin and write JSON data to stdout. -var msgpack = require('msgpack'); -var net = require('net'); -var sys = require('sys'); +'use strict'; -var s = new net.Stream(0); -s.addListener('data', function(b) { - sys.puts(JSON.stringify(msgpack.unpack(b))); +const msgpack = require('../lib/msgpack'); + +const chunks = []; + +process.stdin.on('data', (d) => chunks.push(d)); + +process.stdin.on('end', () => { + let buf = Buffer.concat(chunks); + + while (buf.length > 0) { + let msg; + try { + msg = msgpack.unpack(buf); + } catch (err) { + console.error('msgpack2json: ' + err.message); + process.exitCode = 1; + return; + } + + // null with nothing consumed means the message is incomplete. + if (msg === null && msgpack.unpack.bytes_remaining === buf.length) { + console.error('msgpack2json: incomplete MessagePack data on stdin'); + process.exitCode = 1; + return; + } + + console.log(JSON.stringify(msg)); + + const remaining = msgpack.unpack.bytes_remaining; + buf = remaining > 0 ? buf.subarray(buf.length - remaining) : buf.subarray(buf.length); + } }); -s.resume(); // vim:ts=4 sw=4 et filetype=javascript diff --git a/binding.gyp b/binding.gyp index 9567d49..e17b170 100644 --- a/binding.gyp +++ b/binding.gyp @@ -1,74 +1,53 @@ { - "targets": [ - { - 'target_name': 'msgpackBinding', - 'sources': [ - 'src/msgpack.cc', - ], - 'include_dirs': [ - 'deps/msgpack', - ' diff --git a/deps/msgpack/COPYING b/deps/msgpack/COPYING deleted file mode 100644 index 4388e8f..0000000 --- a/deps/msgpack/COPYING +++ /dev/null @@ -1,14 +0,0 @@ -Copyright (C) 2008-2010 FURUHASHI Sadayuki - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. - diff --git a/deps/msgpack/LICENSE b/deps/msgpack/LICENSE index d645695..36b7cd9 100644 --- a/deps/msgpack/LICENSE +++ b/deps/msgpack/LICENSE @@ -1,202 +1,23 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/deps/msgpack/LICENSE_1_0.txt b/deps/msgpack/LICENSE_1_0.txt new file mode 100644 index 0000000..36b7cd9 --- /dev/null +++ b/deps/msgpack/LICENSE_1_0.txt @@ -0,0 +1,23 @@ +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/deps/msgpack/VERSION b/deps/msgpack/VERSION new file mode 100644 index 0000000..c2c2349 --- /dev/null +++ b/deps/msgpack/VERSION @@ -0,0 +1,7 @@ +msgpack-c c-7.0.2 +git: https://github.com/msgpack/msgpack-c +tag: c-7.0.2 +commit: e17beb371b59459a13b48e166a11e123bda5bf93 +license: Boost Software License 1.0 +notes: C library only. sysdep.h and pack_template.h generated for little-endian. + unpack.c array/map callbacks cap n at MSGPACK_NODE_MAX_CONTAINER (1e6). diff --git a/deps/msgpack/gcc_atomic.hpp b/deps/msgpack/gcc_atomic.hpp deleted file mode 100644 index 7e6dc00..0000000 --- a/deps/msgpack/gcc_atomic.hpp +++ /dev/null @@ -1,41 +0,0 @@ -// -// MessagePack for C++ old gcc workaround for atomic operation -// -// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -#ifndef MSGPACK_GCC_ATOMIC_HPP -#define MSGPACK_GCC_ATOMIC_HPP - -#ifdef ENABLE_GCC_CXX_ATOMIC -#if defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) - -#include "msgpack/gcc_atomic.h" -#include - -int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) -{ - return __gnu_cxx::__exchange_and_add(ptr, -1) - 1; -} - -int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr) -{ - return __gnu_cxx::__exchange_and_add(ptr, 1) + 1; -} - -#endif // old gcc workaround -#endif // ENABLE_GCC_CXX_ATOMIC - -#endif /* gcc_atomic.hpp */ diff --git a/deps/msgpack/include/msgpack.h b/deps/msgpack/include/msgpack.h new file mode 100644 index 0000000..af557a5 --- /dev/null +++ b/deps/msgpack/include/msgpack.h @@ -0,0 +1,24 @@ +/* + * MessagePack for C + * + * Copyright (C) 2008-2009 FURUHASHI Sadayuki + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +/** + * @defgroup msgpack MessagePack C + * @{ + * @} + */ + +#include "msgpack/util.h" +#include "msgpack/object.h" +#include "msgpack/zone.h" +#include "msgpack/pack.h" +#include "msgpack/unpack.h" +#include "msgpack/sbuffer.h" +#include "msgpack/vrefbuffer.h" +#include "msgpack/version.h" + diff --git a/deps/msgpack/include/msgpack/fbuffer.h b/deps/msgpack/include/msgpack/fbuffer.h new file mode 100644 index 0000000..5c847dd --- /dev/null +++ b/deps/msgpack/include/msgpack/fbuffer.h @@ -0,0 +1,42 @@ +/* + * MessagePack for C FILE* buffer adaptor + * + * Copyright (C) 2013 Vladimir Volodko + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +#ifndef MSGPACK_FBUFFER_H +#define MSGPACK_FBUFFER_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @defgroup msgpack_fbuffer FILE* buffer + * @ingroup msgpack_buffer + * @{ + */ + +static inline int msgpack_fbuffer_write(void* data, const char* buf, size_t len) +{ + assert(buf || len == 0); + if(!buf) return 0; + + return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1; +} + +/** @} */ + + +#ifdef __cplusplus +} +#endif + +#endif /* msgpack/fbuffer.h */ diff --git a/deps/msgpack/include/msgpack/gcc_atomic.h b/deps/msgpack/include/msgpack/gcc_atomic.h new file mode 100644 index 0000000..6b1b1a7 --- /dev/null +++ b/deps/msgpack/include/msgpack/gcc_atomic.h @@ -0,0 +1,25 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ + +#ifndef MSGPACK_GCC_ATOMIC_H +#define MSGPACK_GCC_ATOMIC_H + +#if defined(__cplusplus) +extern "C" { +#endif + +typedef int _msgpack_atomic_counter_t; + +int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); +int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); + + +#if defined(__cplusplus) +} +#endif + + +#endif // MSGPACK_GCC_ATOMIC_H diff --git a/deps/msgpack/msgpack/object.h b/deps/msgpack/include/msgpack/object.h similarity index 62% rename from deps/msgpack/msgpack/object.h rename to deps/msgpack/include/msgpack/object.h index 229f6b4..b92b985 100644 --- a/deps/msgpack/msgpack/object.h +++ b/deps/msgpack/include/msgpack/object.h @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_OBJECT_H #define MSGPACK_OBJECT_H @@ -37,6 +29,8 @@ typedef enum { MSGPACK_OBJECT_BOOLEAN = 0x01, MSGPACK_OBJECT_POSITIVE_INTEGER = 0x02, MSGPACK_OBJECT_NEGATIVE_INTEGER = 0x03, + MSGPACK_OBJECT_FLOAT32 = 0x0a, + MSGPACK_OBJECT_FLOAT64 = 0x04, MSGPACK_OBJECT_FLOAT = 0x04, #if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) MSGPACK_OBJECT_DOUBLE = MSGPACK_OBJECT_FLOAT, /* obsolete */ @@ -103,8 +97,46 @@ typedef struct msgpack_object_kv { msgpack_object val; } msgpack_object_kv; +MSGPACK_DLLEXPORT +void msgpack_object_init_nil(msgpack_object* d); + +MSGPACK_DLLEXPORT +void msgpack_object_init_boolean(msgpack_object* d, bool v); + +MSGPACK_DLLEXPORT +void msgpack_object_init_unsigned_integer(msgpack_object* d, uint64_t v); + +MSGPACK_DLLEXPORT +void msgpack_object_init_signed_integer(msgpack_object* d, int64_t v); + +MSGPACK_DLLEXPORT +void msgpack_object_init_float32(msgpack_object* d, float v); + +MSGPACK_DLLEXPORT +void msgpack_object_init_float64(msgpack_object* d, double v); + +MSGPACK_DLLEXPORT +void msgpack_object_init_str(msgpack_object* d, const char* data, uint32_t size); + +MSGPACK_DLLEXPORT +void msgpack_object_init_bin(msgpack_object* d, const char* data, uint32_t size); + +MSGPACK_DLLEXPORT +void msgpack_object_init_ext(msgpack_object* d, int8_t type, const char* data, uint32_t size); + +MSGPACK_DLLEXPORT +void msgpack_object_init_array(msgpack_object* d, msgpack_object* data, uint32_t size); + +MSGPACK_DLLEXPORT +void msgpack_object_init_map(msgpack_object* d, msgpack_object_kv* data, uint32_t size); + +#if !defined(_KERNEL_MODE) MSGPACK_DLLEXPORT void msgpack_object_print(FILE* out, msgpack_object o); +#endif + +MSGPACK_DLLEXPORT +int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o); MSGPACK_DLLEXPORT bool msgpack_object_equal(const msgpack_object x, const msgpack_object y); diff --git a/deps/msgpack/msgpack/pack.h b/deps/msgpack/include/msgpack/pack.h similarity index 76% rename from deps/msgpack/msgpack/pack.h rename to deps/msgpack/include/msgpack/pack.h index ea0fbf7..08ab84b 100644 --- a/deps/msgpack/msgpack/pack.h +++ b/deps/msgpack/include/msgpack/pack.h @@ -3,23 +3,16 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_PACK_H #define MSGPACK_PACK_H #include "pack_define.h" #include "object.h" +#include "timestamp.h" #include #ifdef __cplusplus @@ -96,13 +89,22 @@ static int msgpack_pack_map(msgpack_packer* pk, size_t n); static int msgpack_pack_str(msgpack_packer* pk, size_t l); static int msgpack_pack_str_body(msgpack_packer* pk, const void* b, size_t l); +static int msgpack_pack_str_with_body(msgpack_packer* pk, const void* b, size_t l); + +static int msgpack_pack_v4raw(msgpack_packer* pk, size_t l); +static int msgpack_pack_v4raw_body(msgpack_packer* pk, const void* b, size_t l); static int msgpack_pack_bin(msgpack_packer* pk, size_t l); static int msgpack_pack_bin_body(msgpack_packer* pk, const void* b, size_t l); +static int msgpack_pack_bin_with_body(msgpack_packer* pk, const void* b, size_t l); static int msgpack_pack_ext(msgpack_packer* pk, size_t l, int8_t type); static int msgpack_pack_ext_body(msgpack_packer* pk, const void* b, size_t l); +static int msgpack_pack_ext_with_body(msgpack_packer* pk, const void* b, size_t l, int8_t type); +static int msgpack_pack_timestamp(msgpack_packer* pk, const msgpack_timestamp* d); + +MSGPACK_DLLEXPORT int msgpack_pack_object(msgpack_packer* pk, msgpack_object d); @@ -144,10 +146,29 @@ inline void msgpack_packer_free(msgpack_packer* pk) free(pk); } - +inline int msgpack_pack_str_with_body(msgpack_packer* pk, const void* b, size_t l) + { + int ret = msgpack_pack_str(pk, l); + if (ret != 0) { return ret; } + return msgpack_pack_str_body(pk, b, l); + } + + inline int msgpack_pack_bin_with_body(msgpack_packer* pk, const void* b, size_t l) + { + int ret = msgpack_pack_bin(pk, l); + if (ret != 0) { return ret; } + return msgpack_pack_bin_body(pk, b, l); + } + + inline int msgpack_pack_ext_with_body(msgpack_packer* pk, const void* b, size_t l, int8_t type) + { + int ret = msgpack_pack_ext(pk, l, type); + if (ret != 0) { return ret; } + return msgpack_pack_ext_body(pk, b, l); + } + #ifdef __cplusplus } #endif #endif /* msgpack/pack.h */ - diff --git a/deps/msgpack/include/msgpack/pack_define.h b/deps/msgpack/include/msgpack/pack_define.h new file mode 100644 index 0000000..ce98b67 --- /dev/null +++ b/deps/msgpack/include/msgpack/pack_define.h @@ -0,0 +1,18 @@ +/* + * MessagePack unpacking routine template + * + * Copyright (C) 2008-2010 FURUHASHI Sadayuki + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +#ifndef MSGPACK_PACK_DEFINE_H +#define MSGPACK_PACK_DEFINE_H + +#include "msgpack/sysdep.h" +#include +#include + +#endif /* msgpack/pack_define.h */ + diff --git a/deps/msgpack/msgpack/pack_template.h b/deps/msgpack/include/msgpack/pack_template.h similarity index 89% rename from deps/msgpack/msgpack/pack_template.h rename to deps/msgpack/include/msgpack/pack_template.h index c417cd3..53953fa 100644 --- a/deps/msgpack/msgpack/pack_template.h +++ b/deps/msgpack/include/msgpack/pack_template.h @@ -3,29 +3,30 @@ * * Copyright (C) 2008-2010 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ -#if defined(__LITTLE_ENDIAN__) +#ifndef MSGPACK_ENDIAN_BIG_BYTE +#define MSGPACK_ENDIAN_BIG_BYTE 0 +#endif +#ifndef MSGPACK_ENDIAN_LITTLE_BYTE +#define MSGPACK_ENDIAN_LITTLE_BYTE 1 +#endif + +#if MSGPACK_ENDIAN_LITTLE_BYTE #define TAKE8_8(d) ((uint8_t*)&d)[0] #define TAKE8_16(d) ((uint8_t*)&d)[0] #define TAKE8_32(d) ((uint8_t*)&d)[0] #define TAKE8_64(d) ((uint8_t*)&d)[0] -#elif defined(__BIG_ENDIAN__) +#elif MSGPACK_ENDIAN_BIG_BYTE #define TAKE8_8(d) ((uint8_t*)&d)[0] #define TAKE8_16(d) ((uint8_t*)&d)[1] #define TAKE8_32(d) ((uint8_t*)&d)[3] #define TAKE8_64(d) ((uint8_t*)&d)[7] +#else +#error msgpack-c supports only big endian and little endian #endif #ifndef msgpack_pack_inline_func @@ -40,6 +41,10 @@ #error msgpack_pack_append_buffer callback is not defined #endif +#if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4204) /* nonstandard extension used: non-constant aggregate initializer */ +#endif /* * Integer @@ -669,7 +674,9 @@ msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d) union { double f; uint64_t i; } mem; mem.f = d; buf[0] = 0xcb; -#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi +#if defined(TARGET_OS_IPHONE) + // ok +#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif @@ -777,6 +784,31 @@ msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l msgpack_pack_append_buffer(x, (const unsigned char*)b, l); } +/* + * Raw (V4) + */ + +msgpack_pack_inline_func(_v4raw)(msgpack_pack_user x, size_t l) +{ + if(l < 32) { + unsigned char d = 0xa0 | (uint8_t)l; + msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); + } else if(l < 65536) { + unsigned char buf[3]; + buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); + msgpack_pack_append_buffer(x, buf, 3); + } else { + unsigned char buf[5]; + buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); + msgpack_pack_append_buffer(x, buf, 5); + } +} + +msgpack_pack_inline_func(_v4raw_body)(msgpack_pack_user x, const void* b, size_t l) +{ + msgpack_pack_append_buffer(x, (const unsigned char*)b, l); +} + /* * Bin */ @@ -813,31 +845,31 @@ msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type) case 1: { unsigned char buf[2]; buf[0] = 0xd4; - buf[1] = type; + buf[1] = (unsigned char)type; msgpack_pack_append_buffer(x, buf, 2); } break; case 2: { unsigned char buf[2]; buf[0] = 0xd5; - buf[1] = type; + buf[1] = (unsigned char)type; msgpack_pack_append_buffer(x, buf, 2); } break; case 4: { unsigned char buf[2]; buf[0] = 0xd6; - buf[1] = type; + buf[1] = (unsigned char)type; msgpack_pack_append_buffer(x, buf, 2); } break; case 8: { unsigned char buf[2]; buf[0] = 0xd7; - buf[1] = type; + buf[1] = (unsigned char)type; msgpack_pack_append_buffer(x, buf, 2); } break; case 16: { unsigned char buf[2]; buf[0] = 0xd8; - buf[1] = type; + buf[1] = (unsigned char)type; msgpack_pack_append_buffer(x, buf, 2); } break; default: @@ -845,19 +877,19 @@ msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type) unsigned char buf[3]; buf[0] = 0xc7; buf[1] = (unsigned char)l; - buf[2] = type; + buf[2] = (unsigned char)type; msgpack_pack_append_buffer(x, buf, 3); } else if(l < 65536) { unsigned char buf[4]; buf[0] = 0xc8; _msgpack_store16(&buf[1], l); - buf[3] = type; + buf[3] = (unsigned char)type; msgpack_pack_append_buffer(x, buf, 4); } else { unsigned char buf[6]; buf[0] = 0xc9; _msgpack_store32(&buf[1], l); - buf[5] = type; + buf[5] = (unsigned char)type; msgpack_pack_append_buffer(x, buf, 6); } break; @@ -869,6 +901,34 @@ msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l msgpack_pack_append_buffer(x, (const unsigned char*)b, l); } +msgpack_pack_inline_func(_timestamp)(msgpack_pack_user x, const msgpack_timestamp* d) +{ + if ((((int64_t)d->tv_sec) >> 34) == 0) { + uint64_t data64 = ((uint64_t) d->tv_nsec << 34) | (uint64_t)d->tv_sec; + if ((data64 & 0xffffffff00000000L) == 0) { + // timestamp 32 + char buf[4]; + uint32_t data32 = (uint32_t)data64; + msgpack_pack_ext(x, 4, -1); + _msgpack_store32(buf, data32); + msgpack_pack_append_buffer(x, buf, 4); + } else { + // timestamp 64 + char buf[8]; + msgpack_pack_ext(x, 8, -1); + _msgpack_store64(buf, data64); + msgpack_pack_append_buffer(x, buf, 8); + } + } else { + // timestamp 96 + char buf[12]; + _msgpack_store32(&buf[0], d->tv_nsec); + _msgpack_store64(&buf[4], d->tv_sec); + msgpack_pack_ext(x, 12, -1); + msgpack_pack_append_buffer(x, buf, 12); + } +} + #undef msgpack_pack_inline_func #undef msgpack_pack_user #undef msgpack_pack_append_buffer @@ -887,3 +947,6 @@ msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l #undef msgpack_pack_real_int32 #undef msgpack_pack_real_int64 +#if defined(_MSC_VER) +# pragma warning(pop) +#endif diff --git a/deps/msgpack/msgpack/sbuffer.h b/deps/msgpack/include/msgpack/sbuffer.h similarity index 78% rename from deps/msgpack/msgpack/sbuffer.h rename to deps/msgpack/include/msgpack/sbuffer.h index 4120293..572d8f2 100644 --- a/deps/msgpack/msgpack/sbuffer.h +++ b/deps/msgpack/include/msgpack/sbuffer.h @@ -3,23 +3,16 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_SBUFFER_H #define MSGPACK_SBUFFER_H #include #include +#include #ifdef __cplusplus extern "C" { @@ -68,6 +61,9 @@ static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len) { msgpack_sbuffer* sbuf = (msgpack_sbuffer*)data; + assert(buf || len == 0); + if(!buf) return 0; + if(sbuf->alloc - sbuf->size < len) { void* tmp; size_t nsize = (sbuf->alloc) ? @@ -91,6 +87,7 @@ static inline int msgpack_sbuffer_write(void* data, const char* buf, size_t len) memcpy(sbuf->data + sbuf->size, buf, len); sbuf->size += len; + return 0; } diff --git a/deps/msgpack/include/msgpack/sysdep.h b/deps/msgpack/include/msgpack/sysdep.h new file mode 100644 index 0000000..8f6f461 --- /dev/null +++ b/deps/msgpack/include/msgpack/sysdep.h @@ -0,0 +1,228 @@ +/* + * MessagePack system dependencies + * + * Copyright (C) 2008-2010 FURUHASHI Sadayuki + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +#ifndef MSGPACK_SYSDEP_H +#define MSGPACK_SYSDEP_H + +#include +#include + +#ifndef MSGPACK_ENDIAN_BIG_BYTE +#define MSGPACK_ENDIAN_BIG_BYTE 0 +#endif +#ifndef MSGPACK_ENDIAN_LITTLE_BYTE +#define MSGPACK_ENDIAN_LITTLE_BYTE 1 +#endif + +#if defined(_MSC_VER) && _MSC_VER <= 1800 +# define snprintf(buf, len, format,...) _snprintf_s(buf, len, _TRUNCATE, format, __VA_ARGS__) +#endif + +#if defined(_MSC_VER) && _MSC_VER < 1600 + typedef signed __int8 int8_t; + typedef unsigned __int8 uint8_t; + typedef signed __int16 int16_t; + typedef unsigned __int16 uint16_t; + typedef signed __int32 int32_t; + typedef unsigned __int32 uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; +# if defined(_WIN64) + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +# else + typedef signed __int32 intptr_t; + typedef unsigned __int32 uintptr_t; +# endif +#elif defined(_MSC_VER) // && _MSC_VER >= 1600 +# include +#else +# include +# include +#endif + +#if !defined(MSGPACK_DLLEXPORT) +#if defined(_MSC_VER) +# define MSGPACK_DLLEXPORT __declspec(dllexport) +#else /* _MSC_VER */ +# define MSGPACK_DLLEXPORT +#endif /* _MSC_VER */ +#endif + +#ifdef _WIN32 +# if defined(_KERNEL_MODE) +# define _msgpack_atomic_counter_header +# else +# define _msgpack_atomic_counter_header +# if !defined(WIN32_LEAN_AND_MEAN) +# define WIN32_LEAN_AND_MEAN +# endif /* WIN32_LEAN_AND_MEAN */ +# endif + typedef long _msgpack_atomic_counter_t; +#if defined(_AMD64_) || defined(_M_X64) || defined(_M_ARM64) +# define _msgpack_sync_decr_and_fetch(ptr) _InterlockedDecrement(ptr) +# define _msgpack_sync_incr_and_fetch(ptr) _InterlockedIncrement(ptr) +#else +# define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr) +# define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr) +#endif +#elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) + +# if defined(__cplusplus) +# define _msgpack_atomic_counter_header "msgpack/gcc_atomic.hpp" +# else +# define _msgpack_atomic_counter_header "msgpack/gcc_atomic.h" +# endif + +#else + typedef unsigned int _msgpack_atomic_counter_t; +# define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1) +# define _msgpack_sync_incr_and_fetch(ptr) __sync_add_and_fetch(ptr, 1) +#endif + +#ifdef _WIN32 + +# ifdef __cplusplus + /* numeric_limits::min,max */ +# ifdef max +# undef max +# endif +# ifdef min +# undef min +# endif +# endif + +#elif defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__) + +#include /* __BYTE_ORDER */ +# if defined(linux) +# include +# endif + +#endif + +#if !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE) +#include +#endif // !defined(MSGPACK_ENDIAN_LITTLE_BYTE) && !defined(MSGPACK_ENDIAN_BIG_BYTE) + +#if MSGPACK_ENDIAN_LITTLE_BYTE + +# if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__) +# define _msgpack_be16(x) ntohs((uint16_t)x) +# else +# if defined(ntohs) +# define _msgpack_be16(x) ntohs(x) +# elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400) +# define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x)) +# else +# define _msgpack_be16(x) ( \ + ((((uint16_t)x) << 8) ) | \ + ((((uint16_t)x) >> 8) ) ) +# endif +# endif + +# if defined(unix) || defined(__unix) || defined(__APPLE__) || defined(__OpenBSD__) +# define _msgpack_be32(x) ntohl((uint32_t)x) +# else +# if defined(ntohl) +# define _msgpack_be32(x) ntohl(x) +# elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400) +# define _msgpack_be32(x) ((uint32_t)_byteswap_ulong((unsigned long)x)) +# else +# define _msgpack_be32(x) \ + ( ((((uint32_t)x) << 24) ) | \ + ((((uint32_t)x) << 8) & 0x00ff0000U ) | \ + ((((uint32_t)x) >> 8) & 0x0000ff00U ) | \ + ((((uint32_t)x) >> 24) ) ) +# endif +# endif + +# if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400) +# define _msgpack_be64(x) (_byteswap_uint64(x)) +# elif defined(bswap_64) +# define _msgpack_be64(x) bswap_64(x) +# elif defined(__DARWIN_OSSwapInt64) +# define _msgpack_be64(x) __DARWIN_OSSwapInt64(x) +# else +# define _msgpack_be64(x) \ + ( ((((uint64_t)x) << 56) ) | \ + ((((uint64_t)x) << 40) & 0x00ff000000000000ULL ) | \ + ((((uint64_t)x) << 24) & 0x0000ff0000000000ULL ) | \ + ((((uint64_t)x) << 8) & 0x000000ff00000000ULL ) | \ + ((((uint64_t)x) >> 8) & 0x00000000ff000000ULL ) | \ + ((((uint64_t)x) >> 24) & 0x0000000000ff0000ULL ) | \ + ((((uint64_t)x) >> 40) & 0x000000000000ff00ULL ) | \ + ((((uint64_t)x) >> 56) ) ) +# endif + +#elif MSGPACK_ENDIAN_BIG_BYTE + +# define _msgpack_be16(x) (x) +# define _msgpack_be32(x) (x) +# define _msgpack_be64(x) (x) + +#else +# error msgpack-c supports only big endian and little endian +#endif /* MSGPACK_ENDIAN_LITTLE_BYTE */ + +#define _msgpack_load16(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = (cast)_msgpack_be16(*(to)); \ + } while (0); + +#define _msgpack_load32(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = (cast)_msgpack_be32(*(to)); \ + } while (0); +#define _msgpack_load64(cast, from, to) do { \ + memcpy((cast*)(to), (from), sizeof(cast)); \ + *(to) = (cast)_msgpack_be64(*(to)); \ + } while (0); + +#define _msgpack_store16(to, num) \ + do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0) +#define _msgpack_store32(to, num) \ + do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0) +#define _msgpack_store64(to, num) \ + do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0) + +/* +#define _msgpack_load16(cast, from) \ + ({ cast val; memcpy(&val, (char*)from, 2); _msgpack_be16(val); }) +#define _msgpack_load32(cast, from) \ + ({ cast val; memcpy(&val, (char*)from, 4); _msgpack_be32(val); }) +#define _msgpack_load64(cast, from) \ + ({ cast val; memcpy(&val, (char*)from, 8); _msgpack_be64(val); }) +*/ + + +#if !defined(__cplusplus) && defined(_MSC_VER) +# if !defined(_KERNEL_MODE) +# if !defined(FALSE) +# define FALSE (0) +# endif +# if !defined(TRUE) +# define TRUE (!FALSE) +# endif +# endif +# if _MSC_VER >= 1800 +# include +# else +# define bool int +# define true TRUE +# define false FALSE +# endif +# define inline __inline +#endif + +#ifdef __APPLE__ +# include +#endif + +#endif /* msgpack/sysdep.h */ diff --git a/deps/msgpack/include/msgpack/timestamp.h b/deps/msgpack/include/msgpack/timestamp.h new file mode 100644 index 0000000..7613931 --- /dev/null +++ b/deps/msgpack/include/msgpack/timestamp.h @@ -0,0 +1,58 @@ +/* + * MessagePack for C TimeStamp + * + * Copyright (C) 2018 KONDO Takatoshi + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +#ifndef MSGPACK_TIMESTAMP_H +#define MSGPACK_TIMESTAMP_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +typedef struct msgpack_timestamp { + int64_t tv_sec; + uint32_t tv_nsec; +} msgpack_timestamp; + +static inline bool msgpack_object_to_timestamp(const msgpack_object* obj, msgpack_timestamp* ts) { + if (obj->type != MSGPACK_OBJECT_EXT) return false; + if (obj->via.ext.type != -1) return false; + switch (obj->via.ext.size) { + case 4: + ts->tv_nsec = 0; + { + uint32_t v; + _msgpack_load32(uint32_t, obj->via.ext.ptr, &v); + ts->tv_sec = v; + } + return true; + case 8: { + uint64_t value; + _msgpack_load64(uint64_t, obj->via.ext.ptr, &value); + ts->tv_nsec = (uint32_t)(value >> 34); + ts->tv_sec = value & 0x00000003ffffffffLL; + return true; + } + case 12: + _msgpack_load32(uint32_t, obj->via.ext.ptr, &ts->tv_nsec); + _msgpack_load64(int64_t, obj->via.ext.ptr + 4, &ts->tv_sec); + return true; + default: + return false; + } +} + + +#ifdef __cplusplus +} +#endif + +#endif /* msgpack/timestamp.h */ diff --git a/deps/msgpack/msgpack/unpack.h b/deps/msgpack/include/msgpack/unpack.h similarity index 90% rename from deps/msgpack/msgpack/unpack.h rename to deps/msgpack/include/msgpack/unpack.h index 01bfbcb..036d575 100644 --- a/deps/msgpack/msgpack/unpack.h +++ b/deps/msgpack/include/msgpack/unpack.h @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_UNPACKER_H #define MSGPACK_UNPACKER_H @@ -154,6 +146,18 @@ static inline void msgpack_unpacker_buffer_consumed(msgpack_unpacker* mpac, si MSGPACK_DLLEXPORT msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* pac); +/** + * Deserializes one object and set the number of parsed bytes involved. + * Returns true if it successes. Otherwise false is returned. + * @param mpac pointer to an initialized msgpack_unpacker object. + * @param result pointer to an initialized msgpack_unpacked object. + * @param p_bytes pointer to variable that will be set with the number of parsed bytes. + */ +MSGPACK_DLLEXPORT +msgpack_unpack_return msgpack_unpacker_next_with_size(msgpack_unpacker* mpac, + msgpack_unpacked* result, + size_t *p_bytes); + /** * Initializes a msgpack_unpacked object. * The initialized object must be destroyed by msgpack_unpacked_destroy(msgpack_unpacker*). @@ -275,4 +279,3 @@ static inline msgpack_zone* msgpack_unpacked_release_zone(msgpack_unpacked* resu #endif #endif /* msgpack/unpack.h */ - diff --git a/deps/msgpack/msgpack/unpack_define.h b/deps/msgpack/include/msgpack/unpack_define.h similarity index 78% rename from deps/msgpack/msgpack/unpack_define.h rename to deps/msgpack/include/msgpack/unpack_define.h index 82bd7d5..c7decf6 100644 --- a/deps/msgpack/msgpack/unpack_define.h +++ b/deps/msgpack/include/msgpack/unpack_define.h @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2010 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_UNPACK_DEFINE_H #define MSGPACK_UNPACK_DEFINE_H diff --git a/deps/msgpack/msgpack/unpack_template.h b/deps/msgpack/include/msgpack/unpack_template.h similarity index 86% rename from deps/msgpack/msgpack/unpack_template.h rename to deps/msgpack/include/msgpack/unpack_template.h index 9bf389e..de30f3c 100644 --- a/deps/msgpack/msgpack/unpack_template.h +++ b/deps/msgpack/include/msgpack/unpack_template.h @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2010 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef msgpack_unpack_func @@ -46,6 +38,11 @@ #endif #endif +#if defined(_KERNEL_MODE) +#undef assert +#define assert NT_ASSERT +#endif + msgpack_unpack_struct_decl(_stack) { msgpack_unpack_object obj; size_t count; @@ -117,14 +114,17 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c int ret; #define push_simple_value(func) \ - if(msgpack_unpack_callback(func)(user, &obj) < 0) { goto _failed; } \ + ret = msgpack_unpack_callback(func)(user, &obj); \ + if(ret < 0) { goto _failed; } \ goto _push #define push_fixed_value(func, arg) \ - if(msgpack_unpack_callback(func)(user, arg, &obj) < 0) { goto _failed; } \ + ret = msgpack_unpack_callback(func)(user, arg, &obj); \ + if(ret < 0) { goto _failed; } \ goto _push #define push_variable_value(func, base, pos, len) \ - if(msgpack_unpack_callback(func)(user, \ - (const char*)base, (const char*)pos, len, &obj) < 0) { goto _failed; } \ + ret = msgpack_unpack_callback(func)(user, \ + (const char*)base, (const char*)pos, len, &obj); \ + if(ret < 0) { goto _failed; } \ goto _push #define again_fixed_trail(_cs, trail_len) \ @@ -138,33 +138,16 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c goto _fixed_trail_again #define start_container(func, count_, ct_) \ - if(top >= MSGPACK_EMBED_STACK_SIZE) { goto _failed; } /* FIXME */ \ - if(msgpack_unpack_callback(func)(user, count_, &stack[top].obj) < 0) { goto _failed; } \ + if(top >= MSGPACK_EMBED_STACK_SIZE) { \ + ret = MSGPACK_UNPACK_NOMEM_ERROR; \ + goto _failed; \ + } /* FIXME */ \ + ret = msgpack_unpack_callback(func)(user, count_, &stack[top].obj); \ + if(ret < 0) { goto _failed; } \ if((count_) == 0) { obj = stack[top].obj; goto _push; } \ stack[top].ct = ct_; \ stack[top].count = count_; \ ++top; \ - /*printf("container %d count %d stack %d\n",stack[top].obj,count_,top);*/ \ - /*printf("stack push %d\n", top);*/ \ - /* FIXME \ - if(top >= stack_size) { \ - if(stack_size == MSGPACK_EMBED_STACK_SIZE) { \ - size_t csize = sizeof(msgpack_unpack_struct(_stack)) * MSGPACK_EMBED_STACK_SIZE; \ - size_t nsize = csize * 2; \ - msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)malloc(nsize); \ - if(tmp == NULL) { goto _failed; } \ - memcpy(tmp, ctx->stack, csize); \ - ctx->stack = stack = tmp; \ - ctx->stack_size = stack_size = MSGPACK_EMBED_STACK_SIZE * 2; \ - } else { \ - size_t nsize = sizeof(msgpack_unpack_struct(_stack)) * ctx->stack_size * 2; \ - msgpack_unpack_struct(_stack)* tmp = (msgpack_unpack_struct(_stack)*)realloc(ctx->stack, nsize); \ - if(tmp == NULL) { goto _failed; } \ - ctx->stack = stack = tmp; \ - ctx->stack_size = stack_size = stack_size * 2; \ - } \ - } \ - */ \ goto _header_again #define NEXT_CS(p) \ @@ -239,6 +222,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c case 0xdf: // map 32 again_fixed_trail(NEXT_CS(p), 2u << (((unsigned int)*p) & 0x01)); default: + ret = MSGPACK_UNPACK_PARSE_ERROR; goto _failed; } SWITCH_RANGE(0xa0, 0xbf) // FixStr @@ -249,6 +233,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c start_container(_map, ((unsigned int)*p) & 0x0f, MSGPACK_CT_MAP_KEY); SWITCH_RANGE_DEFAULT + ret = MSGPACK_UNPACK_PARSE_ERROR; goto _failed; SWITCH_RANGE_END // end MSGPACK_CS_HEADER @@ -256,6 +241,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c _fixed_trail_again: ++p; + // fallthrough default: if((size_t)(pe - p) < trail) { goto _out; } @@ -270,7 +256,9 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c case MSGPACK_CS_DOUBLE: { union { uint64_t i; double f; } mem; _msgpack_load64(uint64_t, n, &mem.i); -#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi +#if defined(TARGET_OS_IPHONE) + // ok +#elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi // https://github.com/msgpack/msgpack-perl/pull/1 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); #endif @@ -390,6 +378,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c } default: + ret = MSGPACK_UNPACK_PARSE_ERROR; goto _failed; } } @@ -399,7 +388,8 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c c = &stack[top-1]; switch(c->ct) { case MSGPACK_CT_ARRAY_ITEM: - if(msgpack_unpack_callback(_array_item)(user, &c->obj, obj) < 0) { goto _failed; } + ret = msgpack_unpack_callback(_array_item)(user, &c->obj, obj); \ + if(ret < 0) { goto _failed; } if(--c->count == 0) { obj = c->obj; --top; @@ -412,7 +402,8 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c c->ct = MSGPACK_CT_MAP_VALUE; goto _header_again; case MSGPACK_CT_MAP_VALUE: - if(msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj) < 0) { goto _failed; } + ret = msgpack_unpack_callback(_map_item)(user, &c->obj, c->map_key, obj); \ + if(ret < 0) { goto _failed; } if(--c->count == 0) { obj = c->obj; --top; @@ -423,6 +414,7 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c goto _header_again; default: + ret = MSGPACK_UNPACK_PARSE_ERROR; goto _failed; } @@ -442,7 +434,6 @@ msgpack_unpack_func(int, _execute)(msgpack_unpack_struct(_context)* ctx, const c _failed: /*printf("** FAILED **\n"); */ - ret = -1; goto _end; _out: diff --git a/deps/msgpack/include/msgpack/util.h b/deps/msgpack/include/msgpack/util.h new file mode 100644 index 0000000..959b56b --- /dev/null +++ b/deps/msgpack/include/msgpack/util.h @@ -0,0 +1,15 @@ +/* + * MessagePack for C utilities + * + * Copyright (C) 2014 FURUHASHI Sadayuki + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +#ifndef MSGPACK_UTIL_H +#define MSGPACK_UTIL_H + +#define MSGPACK_UNUSED(a) (void)(a) + +#endif /* MSGPACK_UTIL_H */ diff --git a/deps/msgpack/msgpack/version.h b/deps/msgpack/include/msgpack/version.h similarity index 55% rename from deps/msgpack/msgpack/version.h rename to deps/msgpack/include/msgpack/version.h index 9a58259..bd6605b 100644 --- a/deps/msgpack/msgpack/version.h +++ b/deps/msgpack/include/msgpack/version.h @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_VERSION_H #define MSGPACK_VERSION_H diff --git a/deps/msgpack/include/msgpack/version_master.h b/deps/msgpack/include/msgpack/version_master.h new file mode 100644 index 0000000..ad44609 --- /dev/null +++ b/deps/msgpack/include/msgpack/version_master.h @@ -0,0 +1,3 @@ +#define MSGPACK_VERSION_MAJOR 7 +#define MSGPACK_VERSION_MINOR 0 +#define MSGPACK_VERSION_REVISION 2 diff --git a/deps/msgpack/msgpack/vrefbuffer.h b/deps/msgpack/include/msgpack/vrefbuffer.h similarity index 77% rename from deps/msgpack/msgpack/vrefbuffer.h rename to deps/msgpack/include/msgpack/vrefbuffer.h index 4bc53b9..c263305 100644 --- a/deps/msgpack/msgpack/vrefbuffer.h +++ b/deps/msgpack/include/msgpack/vrefbuffer.h @@ -3,31 +3,26 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_VREFBUFFER_H #define MSGPACK_VREFBUFFER_H #include "zone.h" #include +#include -#ifndef _WIN32 +#if defined(unix) || defined(__unix) || defined(__linux__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__QNX__) || defined(__QNXTO__) || defined(__HAIKU__) #include +typedef struct iovec msgpack_iovec; #else -struct iovec { +struct msgpack_iovec { void *iov_base; size_t iov_len; }; +typedef struct msgpack_iovec msgpack_iovec; #endif #ifdef __cplusplus @@ -51,9 +46,9 @@ typedef struct msgpack_vrefbuffer_inner_buffer { } msgpack_vrefbuffer_inner_buffer; typedef struct msgpack_vrefbuffer { - struct iovec* tail; - struct iovec* end; - struct iovec* array; + msgpack_iovec* tail; + msgpack_iovec* end; + msgpack_iovec* array; size_t chunk_size; size_t ref_size; @@ -81,7 +76,7 @@ static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf); static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len); -static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref); +static inline const msgpack_iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref); static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref); MSGPACK_DLLEXPORT @@ -122,6 +117,9 @@ static inline void msgpack_vrefbuffer_free(msgpack_vrefbuffer* vbuf) static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t len) { msgpack_vrefbuffer* vbuf = (msgpack_vrefbuffer*)data; + assert(buf || len == 0); + + if(!buf) return 0; if(len < vbuf->ref_size) { return msgpack_vrefbuffer_append_copy(vbuf, buf, len); @@ -130,7 +128,7 @@ static inline int msgpack_vrefbuffer_write(void* data, const char* buf, size_t l } } -static inline const struct iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref) +static inline const msgpack_iovec* msgpack_vrefbuffer_vec(const msgpack_vrefbuffer* vref) { return vref->array; } @@ -146,4 +144,3 @@ static inline size_t msgpack_vrefbuffer_veclen(const msgpack_vrefbuffer* vref) #endif #endif /* msgpack/vrefbuffer.h */ - diff --git a/deps/msgpack/msgpack/zbuffer.h b/deps/msgpack/include/msgpack/zbuffer.h similarity index 69% rename from deps/msgpack/msgpack/zbuffer.h rename to deps/msgpack/include/msgpack/zbuffer.h index dbad72c..c38d627 100644 --- a/deps/msgpack/msgpack/zbuffer.h +++ b/deps/msgpack/include/msgpack/zbuffer.h @@ -3,17 +3,9 @@ * * Copyright (C) 2010 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_ZBUFFER_H #define MSGPACK_ZBUFFER_H @@ -21,6 +13,7 @@ #include "sysdep.h" #include #include +#include #include #ifdef __cplusplus @@ -70,7 +63,7 @@ static inline int msgpack_zbuffer_write(void* data, const char* buf, size_t len) static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf); -bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf, +static inline bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf, int level, size_t init_size) { memset(zbuf, 0, sizeof(msgpack_zbuffer)); @@ -82,13 +75,13 @@ bool msgpack_zbuffer_init(msgpack_zbuffer* zbuf, return true; } -void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf) +static inline void msgpack_zbuffer_destroy(msgpack_zbuffer* zbuf) { deflateEnd(&zbuf->stream); free(zbuf->data); } -msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size) +static inline msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size) { msgpack_zbuffer* zbuf = (msgpack_zbuffer*)malloc(sizeof(msgpack_zbuffer)); if (zbuf == NULL) return NULL; @@ -99,17 +92,18 @@ msgpack_zbuffer* msgpack_zbuffer_new(int level, size_t init_size) return zbuf; } -void msgpack_zbuffer_free(msgpack_zbuffer* zbuf) +static inline void msgpack_zbuffer_free(msgpack_zbuffer* zbuf) { if(zbuf == NULL) { return; } msgpack_zbuffer_destroy(zbuf); free(zbuf); } -bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf) +static inline bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf) { - size_t used = (char*)zbuf->stream.next_out - zbuf->data; + size_t used = (size_t)((char *)(zbuf->stream.next_out) - zbuf->data); size_t csize = used + zbuf->stream.avail_out; + size_t nsize = (csize == 0) ? zbuf->init_size : csize * 2; char* tmp = (char*)realloc(zbuf->data, nsize); @@ -119,19 +113,22 @@ bool msgpack_zbuffer_expand(msgpack_zbuffer* zbuf) zbuf->data = tmp; zbuf->stream.next_out = (Bytef*)(tmp + used); - zbuf->stream.avail_out = nsize - used; + zbuf->stream.avail_out = (uInt)(nsize - used); return true; } -int msgpack_zbuffer_write(void* data, const char* buf, size_t len) +static inline int msgpack_zbuffer_write(void* data, const char* buf, size_t len) { msgpack_zbuffer* zbuf = (msgpack_zbuffer*)data; + assert(buf || len == 0); + if(!buf) return 0; + zbuf->stream.next_in = (Bytef*)buf; - zbuf->stream.avail_in = len; + zbuf->stream.avail_in = (uInt)len; - do { + while(zbuf->stream.avail_in > 0) { if(zbuf->stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { if(!msgpack_zbuffer_expand(zbuf)) { return -1; @@ -141,18 +138,19 @@ int msgpack_zbuffer_write(void* data, const char* buf, size_t len) if(deflate(&zbuf->stream, Z_NO_FLUSH) != Z_OK) { return -1; } - } while(zbuf->stream.avail_in > 0); + } return 0; } -char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf) +static inline char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf) { while(true) { switch(deflate(&zbuf->stream, Z_FINISH)) { case Z_STREAM_END: return zbuf->data; case Z_OK: + case Z_BUF_ERROR: if(!msgpack_zbuffer_expand(zbuf)) { return NULL; } @@ -163,23 +161,23 @@ char* msgpack_zbuffer_flush(msgpack_zbuffer* zbuf) } } -const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf) +static inline const char* msgpack_zbuffer_data(const msgpack_zbuffer* zbuf) { return zbuf->data; } -size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf) +static inline size_t msgpack_zbuffer_size(const msgpack_zbuffer* zbuf) { - return (char*)zbuf->stream.next_out - zbuf->data; + return (size_t)((char *)(zbuf->stream.next_out) - zbuf->data); } -void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf) +static inline void msgpack_zbuffer_reset_buffer(msgpack_zbuffer* zbuf) { - zbuf->stream.avail_out += (char*)zbuf->stream.next_out - zbuf->data; + zbuf->stream.avail_out += (uInt)((char*)zbuf->stream.next_out - zbuf->data); zbuf->stream.next_out = (Bytef*)zbuf->data; } -bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf) +static inline bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf) { if(deflateReset(&zbuf->stream) != Z_OK) { return false; @@ -188,7 +186,7 @@ bool msgpack_zbuffer_reset(msgpack_zbuffer* zbuf) return true; } -char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf) +static inline char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf) { char* tmp = zbuf->data; zbuf->data = NULL; @@ -205,4 +203,3 @@ char* msgpack_zbuffer_release_buffer(msgpack_zbuffer* zbuf) #endif #endif /* msgpack/zbuffer.h */ - diff --git a/deps/msgpack/msgpack/zone.h b/deps/msgpack/include/msgpack/zone.h similarity index 81% rename from deps/msgpack/msgpack/zone.h rename to deps/msgpack/include/msgpack/zone.h index 27668a7..7facd54 100644 --- a/deps/msgpack/msgpack/zone.h +++ b/deps/msgpack/include/msgpack/zone.h @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2010 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #ifndef MSGPACK_ZONE_H #define MSGPACK_ZONE_H @@ -115,11 +107,11 @@ static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size) { char* aligned = (char*)( - (size_t)( + (uintptr_t)( zone->chunk_list.ptr + (MSGPACK_ZONE_ALIGN - 1) - ) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN + ) & ~(uintptr_t)(MSGPACK_ZONE_ALIGN - 1) ); - size_t adjusted_size = size + (aligned - zone->chunk_list.ptr); + size_t adjusted_size = size + (size_t)(aligned - zone->chunk_list.ptr); if(zone->chunk_list.free >= adjusted_size) { zone->chunk_list.free -= adjusted_size; zone->chunk_list.ptr += adjusted_size; @@ -128,7 +120,7 @@ static inline void* msgpack_zone_malloc(msgpack_zone* zone, size_t size) { void* ptr = msgpack_zone_malloc_expand(zone, size + (MSGPACK_ZONE_ALIGN - 1)); if (ptr) { - return (char*)((size_t)(ptr) / MSGPACK_ZONE_ALIGN * MSGPACK_ZONE_ALIGN); + return (char*)((uintptr_t)(ptr) & ~(uintptr_t)(MSGPACK_ZONE_ALIGN - 1)); } } return NULL; diff --git a/deps/msgpack/msgpack.gyp b/deps/msgpack/msgpack.gyp index 9bcbd7b..8bc10a0 100644 --- a/deps/msgpack/msgpack.gyp +++ b/deps/msgpack/msgpack.gyp @@ -1,70 +1,29 @@ { - "targets": [ - { - 'target_name': 'libmsgpack', - 'include_dirs': [ '.' ], - 'type': 'static_library', - 'sources': [ - 'objectc.c', - 'unpack.c', - 'vrefbuffer.c', - 'zone.c', - 'version.c' - ], - 'cflags_cc': [ - '-Wall', - '-O3' - ], - 'cflags': [ - '-Wall', - '-O3' - ], - 'cflags!': [ - '-fno-exceptions', - '-Wno-unused-function' - ], - 'cflags_cc!': [ - '-fno-exceptions', - '-Wno-unused-function' - ], - 'conditions': [ - ['OS=="mac"', { - 'configurations': { - 'Debug': { - 'xcode_settings': { - 'GCC_ENABLE_CPP_EXCEPTIONS': 'YES', - 'WARNING_CFLAGS': ['-Wall', '-Wno-unused-function'], - } - }, - 'Release': { - 'xcode_settings': { - 'GCC_ENABLE_CPP_EXCEPTIONS': 'YES', - 'WARNING_CFLAGS': ['-Wall', '-Wno-unused-function'], - }, - }, - }, - }], - ['OS=="win"', { - 'configurations': { - 'Debug': { - 'msvs_settings': { - 'VCCLCompilerTool': { - 'CompileAs': '2', - 'ExceptionHandling': '1', - }, - }, - }, - 'Release': { - 'msvs_settings': { - 'VCCLCompilerTool': { - 'CompileAs': '2', - 'ExceptionHandling': '1', - }, - }, - }, - }, - }] - ] - }, - ] + "targets": [ + { + "target_name": "libmsgpack", + "type": "static_library", + "include_dirs": [ "include" ], + "direct_dependent_settings": { + "include_dirs": [ "include" ], + "defines": [ "MSGPACK_EMBED_STACK_SIZE=512" ] + }, + "defines": [ + "MSGPACK_ENDIAN_LITTLE_BYTE=1", + "MSGPACK_ENDIAN_BIG_BYTE=0", + "MSGPACK_EMBED_STACK_SIZE=512" + ], + "sources": [ + "src/objectc.c", + "src/unpack.c", + "src/version.c", + "src/vrefbuffer.c", + "src/zone.c" + ], + "cflags": [ "-Wall", "-O3", "-std=c99" ], + "xcode_settings": { + "OTHER_CFLAGS": [ "-Wall", "-O3", "-std=c99" ] + } + } + ] } diff --git a/deps/msgpack/msgpack.h b/deps/msgpack/msgpack.h deleted file mode 100644 index 5bb4494..0000000 --- a/deps/msgpack/msgpack.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - * MessagePack for C - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -/** - * @defgroup msgpack MessagePack C - * @{ - * @} - */ - -#include "msgpack/util.h" -#include "msgpack/object.h" -#include "msgpack/zone.h" -#include "msgpack/pack.h" -#include "msgpack/unpack.h" -#include "msgpack/sbuffer.h" -#include "msgpack/vrefbuffer.h" -#include "msgpack/version.h" - diff --git a/deps/msgpack/msgpack.hpp b/deps/msgpack/msgpack.hpp deleted file mode 100644 index 70dc360..0000000 --- a/deps/msgpack/msgpack.hpp +++ /dev/null @@ -1,26 +0,0 @@ -// -// MessagePack for C++ -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#include "msgpack/object.hpp" -#include "msgpack/iterator.hpp" -#include "msgpack/zone.hpp" -#include "msgpack/pack.hpp" -#include "msgpack/unpack.hpp" -#include "msgpack/sbuffer.hpp" -#include "msgpack/vrefbuffer.hpp" -#include "msgpack/version.hpp" -#include "msgpack/type.hpp" diff --git a/deps/msgpack/msgpack/adaptor/adaptor_base.hpp b/deps/msgpack/msgpack/adaptor/adaptor_base.hpp deleted file mode 100644 index e5f1560..0000000 --- a/deps/msgpack/msgpack/adaptor/adaptor_base.hpp +++ /dev/null @@ -1,92 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_ADAPTOR_BASE_HPP -#define MSGPACK_ADAPTOR_BASE_HPP - -#include "msgpack/object_fwd.hpp" - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -template -class packer; - -namespace adaptor { - -// Adaptor functors - -template -struct convert { - msgpack::object const& operator()(msgpack::object const& o, T& v) const; -}; - -template -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, T const& v) const; -}; - -template -struct object { - void operator()(msgpack::object& o, T const& v) const; -}; - -template -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, T const& v) const; -}; - -} // namespace adaptor - -// operators - -template -inline -msgpack::object const& operator>> (msgpack::object const& o, T& v) { - return adaptor::convert()(o, v); -} - -template -inline -msgpack::packer& operator<< (msgpack::packer& o, T const& v) { - return adaptor::pack()(o, v); -} - -template -inline -void operator<< (msgpack::object& o, T const& v) { - adaptor::object()(o, v); -} - -template -inline -void operator<< (msgpack::object::with_zone& o, T const& v) { - adaptor::object_with_zone()(o, v); -} - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - - -#endif // MSGPACK_ADAPTOR_BASE_HPP diff --git a/deps/msgpack/msgpack/adaptor/bool.hpp b/deps/msgpack/msgpack/adaptor/bool.hpp deleted file mode 100644 index abd914e..0000000 --- a/deps/msgpack/msgpack/adaptor/bool.hpp +++ /dev/null @@ -1,74 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_BOOL_HPP -#define MSGPACK_TYPE_BOOL_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, bool& v) const { - if(o.type != msgpack::type::BOOLEAN) { throw msgpack::type_error(); } - v = o.via.boolean; - return o; - } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const bool& v) const { - if(v) { o.pack_true(); } - else { o.pack_false(); } - return o; - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, bool v) const { - o.type = msgpack::type::BOOLEAN; - o.via.boolean = v; - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, bool v) const { - static_cast(o) << v; - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_BOOL_HPP diff --git a/deps/msgpack/msgpack/adaptor/char_ptr.hpp b/deps/msgpack/msgpack/adaptor/char_ptr.hpp deleted file mode 100644 index 14f82ea..0000000 --- a/deps/msgpack/msgpack/adaptor/char_ptr.hpp +++ /dev/null @@ -1,165 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2014-2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_CHAR_PTR_HPP -#define MSGPACK_TYPE_CHAR_PTR_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/object_fwd.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.pack_str(size); - o.pack_str_body(v, size); - return o; - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.type = msgpack::type::STR; - char* ptr = static_cast(o.zone.allocate_align(size)); - o.via.str.ptr = ptr; - o.via.str.size = size; - std::memcpy(ptr, v, size); - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.type = msgpack::type::STR; - o.via.str.ptr = v; - o.via.str.size = size; - } -}; - - -template <> -struct pack { - template - packer& operator()(packer& o, char* v) const { - return o << static_cast(v); - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, char* v) const { - o << static_cast(v); - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, char* v) const { - o << static_cast(v); - } -}; - -template -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.pack_str(size); - o.pack_str_body(v, size); - return o; - } -}; - -template -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.type = msgpack::type::STR; - char* ptr = static_cast(o.zone.allocate_align(size)); - o.via.str.ptr = ptr; - o.via.str.size = size; - std::memcpy(ptr, v, size); - } -}; - -template -struct object { - void operator()(msgpack::object& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.type = msgpack::type::STR; - o.via.str.ptr = v; - o.via.str.size = size; - } -}; - -template -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.pack_str(size); - o.pack_str_body(v, size); - return o; - } -}; - -template -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.type = msgpack::type::STR; - char* ptr = static_cast(o.zone.allocate_align(size)); - o.via.str.ptr = ptr; - o.via.str.size = size; - std::memcpy(ptr, v, size); - } -}; - -template -struct object { - void operator()(msgpack::object& o, const char* v) const { - uint32_t size = checked_get_container_size(std::strlen(v)); - o.type = msgpack::type::STR; - o.via.str.ptr = v; - o.via.str.size = size; - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_CHAR_PTR_HPP diff --git a/deps/msgpack/msgpack/adaptor/check_container_size.hpp b/deps/msgpack/msgpack/adaptor/check_container_size.hpp deleted file mode 100644 index 5fcc128..0000000 --- a/deps/msgpack/msgpack/adaptor/check_container_size.hpp +++ /dev/null @@ -1,65 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CHECK_CONTAINER_SIZE_HPP -#define MSGPACK_CHECK_CONTAINER_SIZE_HPP - -#include "msgpack/versioning.hpp" -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -struct container_size_overflow : public std::runtime_error { - explicit container_size_overflow(const std::string& msg) - :std::runtime_error(msg) {} -#if !defined(MSGPACK_USE_CPP03) - explicit container_size_overflow(const char* msg): - std::runtime_error(msg) {} -#endif // !defined(MSGPACK_USE_CPP03) -}; - -namespace detail { - -template -inline void check_container_size(std::size_t size) { - if (size > 0xffffffff) throw container_size_overflow("container size overflow"); -} - -template <> -inline void check_container_size<4>(std::size_t size) { -} - -} // namespace detail - -template -inline uint32_t checked_get_container_size(T size) { - detail::check_container_size(size); - return static_cast(size); -} - - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_CHECK_CONTAINER_SIZE_HPP diff --git a/deps/msgpack/msgpack/adaptor/cpp11/array.hpp b/deps/msgpack/msgpack/adaptor/cpp11/array.hpp deleted file mode 100644 index d1bc7ca..0000000 --- a/deps/msgpack/msgpack/adaptor/cpp11/array.hpp +++ /dev/null @@ -1,91 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2014-2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -#ifndef MSGPACK_CPP11_ARRAY_HPP -#define MSGPACK_CPP11_ARRAY_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::array& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size != N) { throw msgpack::type_error(); } - if(o.via.array.size > 0) { - msgpack::object* p = o.via.array.ptr; - msgpack::object* const pend = o.via.array.ptr + o.via.array.size; - T* it = &v[0]; - do { - p->convert(*it); - ++p; - ++it; - } while(p < pend); - } - return o; - } -}; - -template -struct pack> { - template - msgpack::packer& operator()(msgpack::packer& o, const std::array& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(auto const& e : v) o.pack(e); - return o; - } -}; - -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::array& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - o.via.array.size = size; - o.via.array.ptr = p; - for (auto const& e : v) *p++ = msgpack::object(e, o.zone); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_CPP11_ARRAY_HPP diff --git a/deps/msgpack/msgpack/adaptor/cpp11/array_char.hpp b/deps/msgpack/msgpack/adaptor/cpp11/array_char.hpp deleted file mode 100644 index 206a3f6..0000000 --- a/deps/msgpack/msgpack/adaptor/cpp11/array_char.hpp +++ /dev/null @@ -1,97 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2014-2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_ARRAY_CHAR_HPP -#define MSGPACK_TYPE_ARRAY_CHAR_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::array& v) const { - switch (o.type) { - case msgpack::type::BIN: - if(o.via.bin.size != N) { throw msgpack::type_error(); } - std::memcpy(v.data(), o.via.bin.ptr, o.via.bin.size); - break; - case msgpack::type::STR: - if(o.via.str.size != N) { throw msgpack::type_error(); } - std::memcpy(v.data(), o.via.str.ptr, N); - break; - default: - throw msgpack::type_error(); - break; - } - return o; - } -}; - -template -struct pack> { - template - msgpack::packer& operator()(msgpack::packer& o, const std::array& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_bin(size); - o.pack_bin_body(v.data(), size); - - return o; - } -}; - -template -struct object> { - void operator()(msgpack::object& o, const std::array& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.type = msgpack::type::BIN; - o.via.bin.ptr = v.data(); - o.via.bin.size = size; - } -}; - -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::array& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.type = msgpack::type::BIN; - char* ptr = static_cast(o.zone.allocate_align(size)); - o.via.bin.ptr = ptr; - o.via.bin.size = size; - std::memcpy(ptr, v.data(), size); - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_ARRAY_CHAR_HPP diff --git a/deps/msgpack/msgpack/adaptor/cpp11/forward_list.hpp b/deps/msgpack/msgpack/adaptor/cpp11/forward_list.hpp deleted file mode 100644 index 337fc20..0000000 --- a/deps/msgpack/msgpack/adaptor/cpp11/forward_list.hpp +++ /dev/null @@ -1,87 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2014 KONDO-2015 Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -#ifndef MSGPACK_CPP11_FORWARD_LIST_HPP -#define MSGPACK_CPP11_FORWARD_LIST_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::forward_list& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - v.resize(o.via.array.size); - msgpack::object* p = o.via.array.ptr; - for (auto &e : v) { - p->convert(e); - ++p; - } - return o; - } -}; - -template -struct pack> { - template - msgpack::packer& operator()(msgpack::packer& o, const std::forward_list& v) const { - uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end())); - o.pack_array(size); - for(auto const& e : v) o.pack(e); - return o; - } -}; - -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::forward_list& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(std::distance(v.begin(), v.end())); - o.via.array.size = size; - msgpack::object* p = static_cast( - o.zone.allocate_align(sizeof(msgpack::object)*size)); - o.via.array.ptr = p; - for(auto const& e : v) *p++ = msgpack::object(e, o.zone); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_CPP11_FORWARD_LIST_HPP diff --git a/deps/msgpack/msgpack/adaptor/cpp11/tuple.hpp b/deps/msgpack/msgpack/adaptor/cpp11/tuple.hpp deleted file mode 100644 index f7a7ea3..0000000 --- a/deps/msgpack/msgpack/adaptor/cpp11/tuple.hpp +++ /dev/null @@ -1,174 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CPP11_TUPLE_HPP -#define MSGPACK_CPP11_TUPLE_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -// --- Pack from tuple to packer stream --- -template -struct StdTuplePacker { - static void pack( - msgpack::packer& o, - const Tuple& v) { - StdTuplePacker::pack(o, v); - o.pack(std::get(v)); - } -}; - -template -struct StdTuplePacker { - static void pack ( - msgpack::packer& o, - const Tuple& v) { - o.pack(std::get<0>(v)); - } -}; - -template -struct StdTuplePacker { - static void pack ( - msgpack::packer&, - const Tuple&) { - } -}; - -namespace adaptor { - -template -struct pack> { - template - msgpack::packer& operator()( - msgpack::packer& o, - const std::tuple& v) const { - uint32_t size = checked_get_container_size(sizeof...(Args)); - o.pack_array(size); - StdTuplePacker::pack(o, v); - return o; - } -}; - -} // namespace adaptor - -// --- Convert from tuple to object --- - -template -struct StdTupleConverter { - static void convert( - msgpack::object const& o, - Tuple& v) { - StdTupleConverter::convert(o, v); - o.via.array.ptr[N-1].convert(v))>::type>(std::get(v)); - } -}; - -template -struct StdTupleConverter { - static void convert ( - msgpack::object const& o, - Tuple& v) { - o.via.array.ptr[0].convert(v))>::type>(std::get<0>(v)); - } -}; - -template -struct StdTupleConverter { - static void convert ( - msgpack::object const&, - Tuple&) { - } -}; - -namespace adaptor { - -template -struct convert> { - msgpack::object const& operator()( - msgpack::object const& o, - std::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); } - StdTupleConverter::convert(o, v); - return o; - } -}; - -} // namespace adaptor - -// --- Convert from tuple to object with zone --- -template -struct StdTupleToObjectWithZone { - static void convert( - msgpack::object::with_zone& o, - const Tuple& v) { - StdTupleToObjectWithZone::convert(o, v); - o.via.array.ptr[N-1] = msgpack::object(std::get(v), o.zone); - } -}; - -template -struct StdTupleToObjectWithZone { - static void convert ( - msgpack::object::with_zone& o, - const Tuple& v) { - o.via.array.ptr[0] = msgpack::object(std::get<0>(v), o.zone); - } -}; - -template -struct StdTupleToObjectWithZone { - static void convert ( - msgpack::object::with_zone&, - const Tuple&) { - } -}; - -namespace adaptor { - -template -struct object_with_zone> { - void operator()( - msgpack::object::with_zone& o, - std::tuple const& v) const { - uint32_t size = checked_get_container_size(sizeof...(Args)); - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - o.via.array.size = size; - StdTupleToObjectWithZone::convert(o, v); - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_CPP11_TUPLE_HPP diff --git a/deps/msgpack/msgpack/adaptor/cpp11/unordered_map.hpp b/deps/msgpack/msgpack/adaptor/cpp11/unordered_map.hpp deleted file mode 100644 index d90ab0f..0000000 --- a/deps/msgpack/msgpack/adaptor/cpp11/unordered_map.hpp +++ /dev/null @@ -1,158 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2014-2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_UNORDERED_MAP_HPP -#define MSGPACK_TYPE_UNORDERED_MAP_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::unordered_map& v) const { - if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } - msgpack::object_kv* p(o.via.map.ptr); - msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::unordered_map tmp; - for(; p != pend; ++p) { - K key; - p->key.convert(key); - p->val.convert(tmp[key]); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack> { - template - msgpack::packer& operator()(msgpack::packer& o, const std::unordered_map& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_map(size); - for(typename std::unordered_map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; - } -}; - -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::unordered_map& v) const { - o.type = msgpack::type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object_kv* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object_kv)*size)); - msgpack::object_kv* const pend = p + size; - o.via.map.ptr = p; - o.via.map.size = size; - typename std::unordered_map::const_iterator it(v.begin()); - do { - p->key = msgpack::object(it->first, o.zone); - p->val = msgpack::object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - - -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::unordered_multimap& v) const { - if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } - msgpack::object_kv* p(o.via.map.ptr); - msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::unordered_multimap tmp; - for(; p != pend; ++p) { - std::pair value; - p->key.convert(value.first); - p->val.convert(value.second); - tmp.insert(value); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack> { - template - msgpack::packer& operator()(msgpack::packer& o, const std::unordered_multimap& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_map(size); - for(typename std::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; - } -}; - -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::unordered_multimap& v) const { - o.type = msgpack::type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object_kv* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object_kv)*size)); - msgpack::object_kv* const pend = p + size; - o.via.map.ptr = p; - o.via.map.size = size; - typename std::unordered_multimap::const_iterator it(v.begin()); - do { - p->key = msgpack::object(it->first, o.zone); - p->val = msgpack::object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - - -#endif // MSGPACK_TYPE_UNORDERED_MAP_HPP diff --git a/deps/msgpack/msgpack/adaptor/cpp11/unordered_set.hpp b/deps/msgpack/msgpack/adaptor/cpp11/unordered_set.hpp deleted file mode 100644 index 386e110..0000000 --- a/deps/msgpack/msgpack/adaptor/cpp11/unordered_set.hpp +++ /dev/null @@ -1,150 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2014-2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_UNORDERED_SET_HPP -#define MSGPACK_TYPE_UNORDERED_SET_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::unordered_set& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - msgpack::object* p = o.via.array.ptr + o.via.array.size; - msgpack::object* const pbegin = o.via.array.ptr; - std::unordered_set tmp; - while(p > pbegin) { - --p; - tmp.insert(p->as()); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack> { - template - msgpack::packer& operator()(msgpack::packer& o, const std::unordered_set& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename std::unordered_set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::unordered_set& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename std::unordered_set::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - - -template -struct convert> { - msgpack::object const& operator()(msgpack::object const& o, std::unordered_multiset& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - msgpack::object* p = o.via.array.ptr + o.via.array.size; - msgpack::object* const pbegin = o.via.array.ptr; - std::unordered_multiset tmp; - while(p > pbegin) { - --p; - tmp.insert(p->as()); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack> { - template - msgpack::packer& operator()(msgpack::packer& o, const std::unordered_multiset& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename std::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone> { - void operator()(msgpack::object::with_zone& o, const std::unordered_multiset& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename std::unordered_multiset::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_UNORDERED_SET_HPP diff --git a/deps/msgpack/msgpack/adaptor/define.hpp b/deps/msgpack/msgpack/adaptor/define.hpp deleted file mode 100644 index bf0b619..0000000 --- a/deps/msgpack/msgpack/adaptor/define.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_DEFINE_HPP -#define MSGPACK_DEFINE_HPP - -#include "msgpack/cpp_config.hpp" - -#if defined(MSGPACK_USE_CPP03) -#include "detail/cpp03_define.hpp" -#else // MSGPACK_USE_CPP03 -#include "detail/cpp11_define.hpp" -#endif // MSGPACK_USE_CPP03 - -#endif // MSGPACK_DEFINE_HPP diff --git a/deps/msgpack/msgpack/adaptor/deque.hpp b/deps/msgpack/msgpack/adaptor/deque.hpp deleted file mode 100644 index 42a5740..0000000 --- a/deps/msgpack/msgpack/adaptor/deque.hpp +++ /dev/null @@ -1,95 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_DEQUE_HPP -#define MSGPACK_TYPE_DEQUE_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::deque& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - v.resize(o.via.array.size); - msgpack::object* p = o.via.array.ptr; - msgpack::object* const pend = o.via.array.ptr + o.via.array.size; - typename std::deque::iterator it = v.begin(); - for(; p < pend; ++p, ++it) { - p->convert(*it); - } - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::deque& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename std::deque::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::deque& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename std::deque::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif /* msgpack/type/deque.hpp */ diff --git a/deps/msgpack/msgpack/adaptor/detail/cpp03_define.hpp b/deps/msgpack/msgpack/adaptor/detail/cpp03_define.hpp deleted file mode 100644 index 7635b93..0000000 --- a/deps/msgpack/msgpack/adaptor/detail/cpp03_define.hpp +++ /dev/null @@ -1,3496 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CPP03_DEFINE_HPP -#define MSGPACK_CPP03_DEFINE_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/msgpack_tuple.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/object_fwd.hpp" - -#define MSGPACK_DEFINE(...) \ - template \ - void msgpack_pack(Packer& pk) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ - } \ - void msgpack_unpack(msgpack::object const& o) \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ - }\ - template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ - } - -// MSGPACK_ADD_ENUM must be used in the global namespace. -#define MSGPACK_ADD_ENUM(enum_name) \ - namespace msgpack { \ - /** @cond */ \ - MSGPACK_API_VERSION_NAMESPACE(v1) { \ - /** @endcond */ \ - namespace adaptor { \ - template<> \ - struct convert { \ - msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const {\ - int tmp; \ - o >> tmp; \ - v = static_cast(tmp); \ - return o; \ - } \ - }; \ - template<> \ - struct object { \ - void operator()(msgpack::object& o, const enum_name& v) const {\ - o << static_cast(v); \ - } \ - }; \ - template<> \ - struct object_with_zone { \ - void operator()(msgpack::object::with_zone& o, const enum_name& v) const { \ - o << static_cast(v); \ - } \ - }; \ - template<> \ - struct pack { \ - template \ - msgpack::packer& operator()(msgpack::packer& o, const enum_name& v) const { \ - return o << static_cast(v); \ - } \ - }; \ - } \ - /** @cond */ \ - } \ - /** @endcond */ \ - } - -namespace msgpack { -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond -namespace type { - -/// @cond - -template -struct define; -/// @endcond - -template <> -struct define<> { - typedef define<> value_type; - typedef tuple<> tuple_type; - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(0); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - } - void msgpack_object(msgpack::object* o, msgpack::zone&) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = nullptr; - o->via.array.size = 0; - } -}; - -/// @cond - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0) : - a0(_a0) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(1); - - pk.pack(a0); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*1)); - o->via.array.size = 1; - - o->via.array.ptr[0] = msgpack::object(a0, z); - } - - A0& a0; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1) : - a0(_a0), a1(_a1) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(2); - - pk.pack(a0); - pk.pack(a1); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*2)); - o->via.array.size = 2; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - } - - A0& a0; - A1& a1; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2) : - a0(_a0), a1(_a1), a2(_a2) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(3); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*3)); - o->via.array.size = 3; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - } - - A0& a0; - A1& a1; - A2& a2; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(4); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*4)); - o->via.array.size = 4; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(5); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*5)); - o->via.array.size = 5; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(6); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*6)); - o->via.array.size = 6; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(7); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*7)); - o->via.array.size = 7; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(8); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*8)); - o->via.array.size = 8; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(9); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*9)); - o->via.array.size = 9; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(10); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*10)); - o->via.array.size = 10; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(11); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*11)); - o->via.array.size = 11; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(12); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*12)); - o->via.array.size = 12; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(13); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*13)); - o->via.array.size = 13; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(14); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*14)); - o->via.array.size = 14; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(15); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*15)); - o->via.array.size = 15; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(16); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*16)); - o->via.array.size = 16; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(17); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*17)); - o->via.array.size = 17; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(18); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*18)); - o->via.array.size = 18; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(19); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*19)); - o->via.array.size = 19; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(20); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*20)); - o->via.array.size = 20; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(21); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*21)); - o->via.array.size = 21; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(22); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*22)); - o->via.array.size = 22; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(23); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*23)); - o->via.array.size = 23; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(24); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*24)); - o->via.array.size = 24; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(25); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*25)); - o->via.array.size = 25; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - o->via.array.ptr[24] = msgpack::object(a24, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(26); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*26)); - o->via.array.size = 26; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - o->via.array.ptr[24] = msgpack::object(a24, z); - o->via.array.ptr[25] = msgpack::object(a25, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(27); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*27)); - o->via.array.size = 27; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - o->via.array.ptr[24] = msgpack::object(a24, z); - o->via.array.ptr[25] = msgpack::object(a25, z); - o->via.array.ptr[26] = msgpack::object(a26, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(28); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*28)); - o->via.array.size = 28; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - o->via.array.ptr[24] = msgpack::object(a24, z); - o->via.array.ptr[25] = msgpack::object(a25, z); - o->via.array.ptr[26] = msgpack::object(a26, z); - o->via.array.ptr[27] = msgpack::object(a27, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(29); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 29: ptr[28].convert(a28); - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*29)); - o->via.array.size = 29; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - o->via.array.ptr[24] = msgpack::object(a24, z); - o->via.array.ptr[25] = msgpack::object(a25, z); - o->via.array.ptr[26] = msgpack::object(a26, z); - o->via.array.ptr[27] = msgpack::object(a27, z); - o->via.array.ptr[28] = msgpack::object(a28, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; - A28& a28; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(30); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 30: ptr[29].convert(a29); - case 29: ptr[28].convert(a28); - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*30)); - o->via.array.size = 30; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - o->via.array.ptr[24] = msgpack::object(a24, z); - o->via.array.ptr[25] = msgpack::object(a25, z); - o->via.array.ptr[26] = msgpack::object(a26, z); - o->via.array.ptr[27] = msgpack::object(a27, z); - o->via.array.ptr[28] = msgpack::object(a28, z); - o->via.array.ptr[29] = msgpack::object(a29, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; - A28& a28; - A29& a29; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(31); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - pk.pack(a30); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 31: ptr[30].convert(a30); - case 30: ptr[29].convert(a29); - case 29: ptr[28].convert(a28); - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*31)); - o->via.array.size = 31; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - o->via.array.ptr[24] = msgpack::object(a24, z); - o->via.array.ptr[25] = msgpack::object(a25, z); - o->via.array.ptr[26] = msgpack::object(a26, z); - o->via.array.ptr[27] = msgpack::object(a27, z); - o->via.array.ptr[28] = msgpack::object(a28, z); - o->via.array.ptr[29] = msgpack::object(a29, z); - o->via.array.ptr[30] = msgpack::object(a30, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; - A28& a28; - A29& a29; - A30& a30; -}; - -template -struct define { - typedef define value_type; - typedef tuple tuple_type; - define(A0& _a0, A1& _a1, A2& _a2, A3& _a3, A4& _a4, A5& _a5, A6& _a6, A7& _a7, A8& _a8, A9& _a9, A10& _a10, A11& _a11, A12& _a12, A13& _a13, A14& _a14, A15& _a15, A16& _a16, A17& _a17, A18& _a18, A19& _a19, A20& _a20, A21& _a21, A22& _a22, A23& _a23, A24& _a24, A25& _a25, A26& _a26, A27& _a27, A28& _a28, A29& _a29, A30& _a30, A31& _a31) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(32); - - pk.pack(a0); - pk.pack(a1); - pk.pack(a2); - pk.pack(a3); - pk.pack(a4); - pk.pack(a5); - pk.pack(a6); - pk.pack(a7); - pk.pack(a8); - pk.pack(a9); - pk.pack(a10); - pk.pack(a11); - pk.pack(a12); - pk.pack(a13); - pk.pack(a14); - pk.pack(a15); - pk.pack(a16); - pk.pack(a17); - pk.pack(a18); - pk.pack(a19); - pk.pack(a20); - pk.pack(a21); - pk.pack(a22); - pk.pack(a23); - pk.pack(a24); - pk.pack(a25); - pk.pack(a26); - pk.pack(a27); - pk.pack(a28); - pk.pack(a29); - pk.pack(a30); - pk.pack(a31); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - const size_t size = o.via.array.size; - if(size > 0) { - msgpack::object *ptr = o.via.array.ptr; - switch(size) { - default: - case 32: ptr[31].convert(a31); - case 31: ptr[30].convert(a30); - case 30: ptr[29].convert(a29); - case 29: ptr[28].convert(a28); - case 28: ptr[27].convert(a27); - case 27: ptr[26].convert(a26); - case 26: ptr[25].convert(a25); - case 25: ptr[24].convert(a24); - case 24: ptr[23].convert(a23); - case 23: ptr[22].convert(a22); - case 22: ptr[21].convert(a21); - case 21: ptr[20].convert(a20); - case 20: ptr[19].convert(a19); - case 19: ptr[18].convert(a18); - case 18: ptr[17].convert(a17); - case 17: ptr[16].convert(a16); - case 16: ptr[15].convert(a15); - case 15: ptr[14].convert(a14); - case 14: ptr[13].convert(a13); - case 13: ptr[12].convert(a12); - case 12: ptr[11].convert(a11); - case 11: ptr[10].convert(a10); - case 10: ptr[9].convert(a9); - case 9: ptr[8].convert(a8); - case 8: ptr[7].convert(a7); - case 7: ptr[6].convert(a6); - case 6: ptr[5].convert(a5); - case 5: ptr[4].convert(a4); - case 4: ptr[3].convert(a3); - case 3: ptr[2].convert(a2); - case 2: ptr[1].convert(a1); - case 1: ptr[0].convert(a0); - } - } - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*32)); - o->via.array.size = 32; - - o->via.array.ptr[0] = msgpack::object(a0, z); - o->via.array.ptr[1] = msgpack::object(a1, z); - o->via.array.ptr[2] = msgpack::object(a2, z); - o->via.array.ptr[3] = msgpack::object(a3, z); - o->via.array.ptr[4] = msgpack::object(a4, z); - o->via.array.ptr[5] = msgpack::object(a5, z); - o->via.array.ptr[6] = msgpack::object(a6, z); - o->via.array.ptr[7] = msgpack::object(a7, z); - o->via.array.ptr[8] = msgpack::object(a8, z); - o->via.array.ptr[9] = msgpack::object(a9, z); - o->via.array.ptr[10] = msgpack::object(a10, z); - o->via.array.ptr[11] = msgpack::object(a11, z); - o->via.array.ptr[12] = msgpack::object(a12, z); - o->via.array.ptr[13] = msgpack::object(a13, z); - o->via.array.ptr[14] = msgpack::object(a14, z); - o->via.array.ptr[15] = msgpack::object(a15, z); - o->via.array.ptr[16] = msgpack::object(a16, z); - o->via.array.ptr[17] = msgpack::object(a17, z); - o->via.array.ptr[18] = msgpack::object(a18, z); - o->via.array.ptr[19] = msgpack::object(a19, z); - o->via.array.ptr[20] = msgpack::object(a20, z); - o->via.array.ptr[21] = msgpack::object(a21, z); - o->via.array.ptr[22] = msgpack::object(a22, z); - o->via.array.ptr[23] = msgpack::object(a23, z); - o->via.array.ptr[24] = msgpack::object(a24, z); - o->via.array.ptr[25] = msgpack::object(a25, z); - o->via.array.ptr[26] = msgpack::object(a26, z); - o->via.array.ptr[27] = msgpack::object(a27, z); - o->via.array.ptr[28] = msgpack::object(a28, z); - o->via.array.ptr[29] = msgpack::object(a29, z); - o->via.array.ptr[30] = msgpack::object(a30, z); - o->via.array.ptr[31] = msgpack::object(a31, z); - } - - A0& a0; - A1& a1; - A2& a2; - A3& a3; - A4& a4; - A5& a5; - A6& a6; - A7& a7; - A8& a8; - A9& a9; - A10& a10; - A11& a11; - A12& a12; - A13& a13; - A14& a14; - A15& a15; - A16& a16; - A17& a17; - A18& a18; - A19& a19; - A20& a20; - A21& a21; - A22& a22; - A23& a23; - A24& a24; - A25& a25; - A26& a26; - A27& a27; - A28& a28; - A29& a29; - A30& a30; - A31& a31; -}; - -/// @endcond - -inline define<> make_define() -{ - return define<>(); -} - -/// @cond - -template -define make_define(A0& a0) -{ - return define(a0); -} - -template -define make_define(A0& a0, A1& a1) -{ - return define(a0, a1); -} - -template -define make_define(A0& a0, A1& a1, A2& a2) -{ - return define(a0, a1, a2); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3) -{ - return define(a0, a1, a2, a3); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4) -{ - return define(a0, a1, a2, a3, a4); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) -{ - return define(a0, a1, a2, a3, a4, a5); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) -{ - return define(a0, a1, a2, a3, a4, a5, a6); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); -} - -template -define make_define(A0& a0, A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10, A11& a11, A12& a12, A13& a13, A14& a14, A15& a15, A16& a16, A17& a17, A18& a18, A19& a19, A20& a20, A21& a21, A22& a22, A23& a23, A24& a24, A25& a25, A26& a26, A27& a27, A28& a28, A29& a29, A30& a30, A31& a31) -{ - return define(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); -} - -/// @endcond - -} // namespace type -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond -} // namespace msgpack - - -#endif // MSGPACK_CPP03_DEFINE_HPP diff --git a/deps/msgpack/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp b/deps/msgpack/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp deleted file mode 100644 index f84b43c..0000000 --- a/deps/msgpack/msgpack/adaptor/detail/cpp03_msgpack_tuple.hpp +++ /dev/null @@ -1,13917 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CPP03_MSGPACK_TUPLE_HPP -#define MSGPACK_CPP03_MSGPACK_TUPLE_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/object.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace type { - -// FIXME operator== -// FIXME operator!= - - -/// @cond -template -struct tuple; -/// @endcond - -template -struct tuple_element; - -template -struct const_tuple_element; - -template -struct tuple_type { - typedef T type; - typedef T value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; -}; - -template -struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef T& transparent_reference; -}; - -template -struct tuple_type { - typedef T type; - typedef T& value_type; - typedef T& reference; - typedef const T& const_reference; - typedef const T& transparent_reference; -}; - -/// @cond - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : m_x(x.a28) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : m_x(x.a28) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : m_x(x.a29) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : m_x(x.a28) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : m_x(x.a29) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 30> : tuple_type { - tuple_element(tuple& x) : m_x(x.a30) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - -template -struct tuple_element, 0> : tuple_type { - tuple_element(tuple& x) : m_x(x.a0) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 1> : tuple_type { - tuple_element(tuple& x) : m_x(x.a1) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 2> : tuple_type { - tuple_element(tuple& x) : m_x(x.a2) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 3> : tuple_type { - tuple_element(tuple& x) : m_x(x.a3) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 4> : tuple_type { - tuple_element(tuple& x) : m_x(x.a4) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 5> : tuple_type { - tuple_element(tuple& x) : m_x(x.a5) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 6> : tuple_type { - tuple_element(tuple& x) : m_x(x.a6) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 7> : tuple_type { - tuple_element(tuple& x) : m_x(x.a7) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 8> : tuple_type { - tuple_element(tuple& x) : m_x(x.a8) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 9> : tuple_type { - tuple_element(tuple& x) : m_x(x.a9) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 10> : tuple_type { - tuple_element(tuple& x) : m_x(x.a10) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 11> : tuple_type { - tuple_element(tuple& x) : m_x(x.a11) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 12> : tuple_type { - tuple_element(tuple& x) : m_x(x.a12) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 13> : tuple_type { - tuple_element(tuple& x) : m_x(x.a13) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 14> : tuple_type { - tuple_element(tuple& x) : m_x(x.a14) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 15> : tuple_type { - tuple_element(tuple& x) : m_x(x.a15) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 16> : tuple_type { - tuple_element(tuple& x) : m_x(x.a16) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 17> : tuple_type { - tuple_element(tuple& x) : m_x(x.a17) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 18> : tuple_type { - tuple_element(tuple& x) : m_x(x.a18) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 19> : tuple_type { - tuple_element(tuple& x) : m_x(x.a19) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 20> : tuple_type { - tuple_element(tuple& x) : m_x(x.a20) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 21> : tuple_type { - tuple_element(tuple& x) : m_x(x.a21) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 22> : tuple_type { - tuple_element(tuple& x) : m_x(x.a22) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 23> : tuple_type { - tuple_element(tuple& x) : m_x(x.a23) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 24> : tuple_type { - tuple_element(tuple& x) : m_x(x.a24) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 25> : tuple_type { - tuple_element(tuple& x) : m_x(x.a25) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 26> : tuple_type { - tuple_element(tuple& x) : m_x(x.a26) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 27> : tuple_type { - tuple_element(tuple& x) : m_x(x.a27) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 28> : tuple_type { - tuple_element(tuple& x) : m_x(x.a28) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 29> : tuple_type { - tuple_element(tuple& x) : m_x(x.a29) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 30> : tuple_type { - tuple_element(tuple& x) : m_x(x.a30) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - -template -struct tuple_element, 31> : tuple_type { - tuple_element(tuple& x) : m_x(x.a31) {} - typename tuple_type::reference get() { return m_x; } - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::reference m_x; -}; - - - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a28) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a28) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a29) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a28) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a29) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 30> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a30) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - - -template -struct const_tuple_element, 0> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a0) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 1> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a1) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 2> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a2) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 3> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a3) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 4> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a4) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 5> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a5) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 6> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a6) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 7> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a7) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 8> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a8) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 9> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a9) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 10> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a10) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 11> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a11) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 12> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a12) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 13> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a13) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 14> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a14) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 15> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a15) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 16> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a16) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 17> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a17) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 18> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a18) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 19> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a19) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 20> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a20) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 21> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a21) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 22> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a22) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 23> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a23) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 24> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a24) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 25> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a25) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 26> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a26) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 27> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a27) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 28> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a28) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 29> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a29) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 30> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a30) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - -template -struct const_tuple_element, 31> : tuple_type { - const_tuple_element(const tuple& x) : m_x(x.a31) {} - typename tuple_type::const_reference get() const { return m_x; } -private: - typename tuple_type::const_reference m_x; -}; - - -/// @endcond - -template <> -struct tuple<> { - tuple() {} - tuple(msgpack::object const& o) { o.convert(*this); } - typedef tuple<> value_type; -}; - -/// @cond - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0) : - a0(_a0) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1) : - a0(_a0), a1(_a1) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2) : - a0(_a0), a1(_a1), a2(_a2) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; - A28 a28; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; - A28 a28; - A29 a29; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; - A28 a28; - A29 a29; - A30 a30; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -template -struct tuple { - typedef tuple value_type; - tuple() {} - tuple(typename tuple_type::transparent_reference _a0, typename tuple_type::transparent_reference _a1, typename tuple_type::transparent_reference _a2, typename tuple_type::transparent_reference _a3, typename tuple_type::transparent_reference _a4, typename tuple_type::transparent_reference _a5, typename tuple_type::transparent_reference _a6, typename tuple_type::transparent_reference _a7, typename tuple_type::transparent_reference _a8, typename tuple_type::transparent_reference _a9, typename tuple_type::transparent_reference _a10, typename tuple_type::transparent_reference _a11, typename tuple_type::transparent_reference _a12, typename tuple_type::transparent_reference _a13, typename tuple_type::transparent_reference _a14, typename tuple_type::transparent_reference _a15, typename tuple_type::transparent_reference _a16, typename tuple_type::transparent_reference _a17, typename tuple_type::transparent_reference _a18, typename tuple_type::transparent_reference _a19, typename tuple_type::transparent_reference _a20, typename tuple_type::transparent_reference _a21, typename tuple_type::transparent_reference _a22, typename tuple_type::transparent_reference _a23, typename tuple_type::transparent_reference _a24, typename tuple_type::transparent_reference _a25, typename tuple_type::transparent_reference _a26, typename tuple_type::transparent_reference _a27, typename tuple_type::transparent_reference _a28, typename tuple_type::transparent_reference _a29, typename tuple_type::transparent_reference _a30, typename tuple_type::transparent_reference _a31) : - a0(_a0), a1(_a1), a2(_a2), a3(_a3), a4(_a4), a5(_a5), a6(_a6), a7(_a7), a8(_a8), a9(_a9), a10(_a10), a11(_a11), a12(_a12), a13(_a13), a14(_a14), a15(_a15), a16(_a16), a17(_a17), a18(_a18), a19(_a19), a20(_a20), a21(_a21), a22(_a22), a23(_a23), a24(_a24), a25(_a25), a26(_a26), a27(_a27), a28(_a28), a29(_a29), a30(_a30), a31(_a31) {} - tuple(msgpack::object const& o) { o.convert(*this); } - template typename tuple_element::reference get() - { return tuple_element(*this).get(); } - template typename const_tuple_element::const_reference get() const - { return const_tuple_element(*this).get(); } - - A0 a0; - A1 a1; - A2 a2; - A3 a3; - A4 a4; - A5 a5; - A6 a6; - A7 a7; - A8 a8; - A9 a9; - A10 a10; - A11 a11; - A12 a12; - A13 a13; - A14 a14; - A15 a15; - A16 a16; - A17 a17; - A18 a18; - A19 a19; - A20 a20; - A21 a21; - A22 a22; - A23 a23; - A24 a24; - A25 a25; - A26 a26; - A27 a27; - A28 a28; - A29 a29; - A30 a30; - A31 a31; -}; - -template -inline typename type::tuple_element, N>::reference get(type::tuple& t) -{ return t.template get(); } -template -inline typename type::const_tuple_element, N>::const_reference get(type::tuple const& t) -{ return t.template get(); } - -/// @endcond - -inline tuple<> make_tuple() -{ - return tuple<>(); -} - -/// @cond - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0) -{ - return tuple(a0); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1) -{ - return tuple(a0, a1); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2) -{ - return tuple(a0, a1, a2); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3) -{ - return tuple(a0, a1, a2, a3); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4) -{ - return tuple(a0, a1, a2, a3, a4); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5) -{ - return tuple(a0, a1, a2, a3, a4, a5); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30); -} - -template -inline tuple make_tuple(typename tuple_type::transparent_reference a0, typename tuple_type::transparent_reference a1, typename tuple_type::transparent_reference a2, typename tuple_type::transparent_reference a3, typename tuple_type::transparent_reference a4, typename tuple_type::transparent_reference a5, typename tuple_type::transparent_reference a6, typename tuple_type::transparent_reference a7, typename tuple_type::transparent_reference a8, typename tuple_type::transparent_reference a9, typename tuple_type::transparent_reference a10, typename tuple_type::transparent_reference a11, typename tuple_type::transparent_reference a12, typename tuple_type::transparent_reference a13, typename tuple_type::transparent_reference a14, typename tuple_type::transparent_reference a15, typename tuple_type::transparent_reference a16, typename tuple_type::transparent_reference a17, typename tuple_type::transparent_reference a18, typename tuple_type::transparent_reference a19, typename tuple_type::transparent_reference a20, typename tuple_type::transparent_reference a21, typename tuple_type::transparent_reference a22, typename tuple_type::transparent_reference a23, typename tuple_type::transparent_reference a24, typename tuple_type::transparent_reference a25, typename tuple_type::transparent_reference a26, typename tuple_type::transparent_reference a27, typename tuple_type::transparent_reference a28, typename tuple_type::transparent_reference a29, typename tuple_type::transparent_reference a30, typename tuple_type::transparent_reference a31) -{ - return tuple(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31); -} - -/// @endcond - -} // namespace type - -namespace adaptor { - -template <> -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple<>&) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - return o; - } -}; - -/// @cond - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 1) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 2) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 3) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 4) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 5) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 6) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 7) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 8) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 9) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 10) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 11) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 12) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 13) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 14) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 15) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 16) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 17) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 18) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 19) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 20) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 21) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 22) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 23) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 24) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 25) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[24].msgpack::object::convert::type>(v.template get<24>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 26) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[24].msgpack::object::convert::type>(v.template get<24>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[25].msgpack::object::convert::type>(v.template get<25>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 27) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[24].msgpack::object::convert::type>(v.template get<24>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[25].msgpack::object::convert::type>(v.template get<25>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[26].msgpack::object::convert::type>(v.template get<26>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 28) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[24].msgpack::object::convert::type>(v.template get<24>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[25].msgpack::object::convert::type>(v.template get<25>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[26].msgpack::object::convert::type>(v.template get<26>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[27].msgpack::object::convert::type>(v.template get<27>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 29) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[24].msgpack::object::convert::type>(v.template get<24>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[25].msgpack::object::convert::type>(v.template get<25>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[26].msgpack::object::convert::type>(v.template get<26>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[27].msgpack::object::convert::type>(v.template get<27>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[28].msgpack::object::convert::type>(v.template get<28>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 30) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[24].msgpack::object::convert::type>(v.template get<24>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[25].msgpack::object::convert::type>(v.template get<25>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[26].msgpack::object::convert::type>(v.template get<26>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[27].msgpack::object::convert::type>(v.template get<27>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[28].msgpack::object::convert::type>(v.template get<28>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[29].msgpack::object::convert::type>(v.template get<29>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 31) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[24].msgpack::object::convert::type>(v.template get<24>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[25].msgpack::object::convert::type>(v.template get<25>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[26].msgpack::object::convert::type>(v.template get<26>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[27].msgpack::object::convert::type>(v.template get<27>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[28].msgpack::object::convert::type>(v.template get<28>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[29].msgpack::object::convert::type>(v.template get<29>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[30].msgpack::object::convert::type>(v.template get<30>()); - return o; - } -}; - -template -struct convert > { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < 32) { throw msgpack::type_error(); } - - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[0].msgpack::object::convert::type>(v.template get<0>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[1].msgpack::object::convert::type>(v.template get<1>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[2].msgpack::object::convert::type>(v.template get<2>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[3].msgpack::object::convert::type>(v.template get<3>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[4].msgpack::object::convert::type>(v.template get<4>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[5].msgpack::object::convert::type>(v.template get<5>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[6].msgpack::object::convert::type>(v.template get<6>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[7].msgpack::object::convert::type>(v.template get<7>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[8].msgpack::object::convert::type>(v.template get<8>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[9].msgpack::object::convert::type>(v.template get<9>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[10].msgpack::object::convert::type>(v.template get<10>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[11].msgpack::object::convert::type>(v.template get<11>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[12].msgpack::object::convert::type>(v.template get<12>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[13].msgpack::object::convert::type>(v.template get<13>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[14].msgpack::object::convert::type>(v.template get<14>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[15].msgpack::object::convert::type>(v.template get<15>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[16].msgpack::object::convert::type>(v.template get<16>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[17].msgpack::object::convert::type>(v.template get<17>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[18].msgpack::object::convert::type>(v.template get<18>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[19].msgpack::object::convert::type>(v.template get<19>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[20].msgpack::object::convert::type>(v.template get<20>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[21].msgpack::object::convert::type>(v.template get<21>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[22].msgpack::object::convert::type>(v.template get<22>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[23].msgpack::object::convert::type>(v.template get<23>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[24].msgpack::object::convert::type>(v.template get<24>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[25].msgpack::object::convert::type>(v.template get<25>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[26].msgpack::object::convert::type>(v.template get<26>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[27].msgpack::object::convert::type>(v.template get<27>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[28].msgpack::object::convert::type>(v.template get<28>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[29].msgpack::object::convert::type>(v.template get<29>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[30].msgpack::object::convert::type>(v.template get<30>()); - // In order to avoid clang++'s invalid warning, msgpack::object:: has been added. - o.via.array.ptr[31].msgpack::object::convert::type>(v.template get<31>()); - return o; - } -}; - -/// @endcond - -template <> -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple<>&) const { - o.pack_array(0); - return o; - } -}; - -/// @cond - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(1); - - o.pack(v.template get<0>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(2); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(3); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(4); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(5); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(6); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(7); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(8); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(9); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(10); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(11); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(12); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(13); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(14); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(15); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(16); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(17); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(18); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(19); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(20); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(21); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(22); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(23); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(24); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(25); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(26); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(27); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(28); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(29); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(30); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(31); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - o.pack(v.template get<30>()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(32); - - o.pack(v.template get<0>()); - o.pack(v.template get<1>()); - o.pack(v.template get<2>()); - o.pack(v.template get<3>()); - o.pack(v.template get<4>()); - o.pack(v.template get<5>()); - o.pack(v.template get<6>()); - o.pack(v.template get<7>()); - o.pack(v.template get<8>()); - o.pack(v.template get<9>()); - o.pack(v.template get<10>()); - o.pack(v.template get<11>()); - o.pack(v.template get<12>()); - o.pack(v.template get<13>()); - o.pack(v.template get<14>()); - o.pack(v.template get<15>()); - o.pack(v.template get<16>()); - o.pack(v.template get<17>()); - o.pack(v.template get<18>()); - o.pack(v.template get<19>()); - o.pack(v.template get<20>()); - o.pack(v.template get<21>()); - o.pack(v.template get<22>()); - o.pack(v.template get<23>()); - o.pack(v.template get<24>()); - o.pack(v.template get<25>()); - o.pack(v.template get<26>()); - o.pack(v.template get<27>()); - o.pack(v.template get<28>()); - o.pack(v.template get<29>()); - o.pack(v.template get<30>()); - o.pack(v.template get<31>()); - return o; - } -}; - -/// @endcond - -template <> -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple<>&) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } -}; - -/// @cond - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*1)); - o.via.array.size = 1; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*2)); - o.via.array.size = 2; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*3)); - o.via.array.size = 3; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*4)); - o.via.array.size = 4; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*5)); - o.via.array.size = 5; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*6)); - o.via.array.size = 6; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*7)); - o.via.array.size = 7; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*8)); - o.via.array.size = 8; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*9)); - o.via.array.size = 9; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*10)); - o.via.array.size = 10; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*11)); - o.via.array.size = 11; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*12)); - o.via.array.size = 12; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*13)); - o.via.array.size = 13; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*14)); - o.via.array.size = 14; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*15)); - o.via.array.size = 15; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*16)); - o.via.array.size = 16; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*17)); - o.via.array.size = 17; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*18)); - o.via.array.size = 18; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*19)); - o.via.array.size = 19; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*20)); - o.via.array.size = 20; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*21)); - o.via.array.size = 21; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*22)); - o.via.array.size = 22; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*23)); - o.via.array.size = 23; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*24)); - o.via.array.size = 24; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*25)); - o.via.array.size = 25; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = msgpack::object(v.template get<24>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*26)); - o.via.array.size = 26; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = msgpack::object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = msgpack::object(v.template get<25>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*27)); - o.via.array.size = 27; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = msgpack::object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = msgpack::object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = msgpack::object(v.template get<26>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*28)); - o.via.array.size = 28; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = msgpack::object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = msgpack::object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = msgpack::object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = msgpack::object(v.template get<27>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*29)); - o.via.array.size = 29; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = msgpack::object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = msgpack::object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = msgpack::object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = msgpack::object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = msgpack::object(v.template get<28>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*30)); - o.via.array.size = 30; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = msgpack::object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = msgpack::object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = msgpack::object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = msgpack::object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = msgpack::object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = msgpack::object(v.template get<29>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*31)); - o.via.array.size = 31; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = msgpack::object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = msgpack::object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = msgpack::object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = msgpack::object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = msgpack::object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = msgpack::object(v.template get<29>(), o.zone); - o.via.array.ptr[30] = msgpack::object(v.template get<30>(), o.zone); - } -}; - -template -struct object_with_zone > { - void operator()( - msgpack::object::with_zone& o, - const type::tuple& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*32)); - o.via.array.size = 32; - - o.via.array.ptr[0] = msgpack::object(v.template get<0>(), o.zone); - o.via.array.ptr[1] = msgpack::object(v.template get<1>(), o.zone); - o.via.array.ptr[2] = msgpack::object(v.template get<2>(), o.zone); - o.via.array.ptr[3] = msgpack::object(v.template get<3>(), o.zone); - o.via.array.ptr[4] = msgpack::object(v.template get<4>(), o.zone); - o.via.array.ptr[5] = msgpack::object(v.template get<5>(), o.zone); - o.via.array.ptr[6] = msgpack::object(v.template get<6>(), o.zone); - o.via.array.ptr[7] = msgpack::object(v.template get<7>(), o.zone); - o.via.array.ptr[8] = msgpack::object(v.template get<8>(), o.zone); - o.via.array.ptr[9] = msgpack::object(v.template get<9>(), o.zone); - o.via.array.ptr[10] = msgpack::object(v.template get<10>(), o.zone); - o.via.array.ptr[11] = msgpack::object(v.template get<11>(), o.zone); - o.via.array.ptr[12] = msgpack::object(v.template get<12>(), o.zone); - o.via.array.ptr[13] = msgpack::object(v.template get<13>(), o.zone); - o.via.array.ptr[14] = msgpack::object(v.template get<14>(), o.zone); - o.via.array.ptr[15] = msgpack::object(v.template get<15>(), o.zone); - o.via.array.ptr[16] = msgpack::object(v.template get<16>(), o.zone); - o.via.array.ptr[17] = msgpack::object(v.template get<17>(), o.zone); - o.via.array.ptr[18] = msgpack::object(v.template get<18>(), o.zone); - o.via.array.ptr[19] = msgpack::object(v.template get<19>(), o.zone); - o.via.array.ptr[20] = msgpack::object(v.template get<20>(), o.zone); - o.via.array.ptr[21] = msgpack::object(v.template get<21>(), o.zone); - o.via.array.ptr[22] = msgpack::object(v.template get<22>(), o.zone); - o.via.array.ptr[23] = msgpack::object(v.template get<23>(), o.zone); - o.via.array.ptr[24] = msgpack::object(v.template get<24>(), o.zone); - o.via.array.ptr[25] = msgpack::object(v.template get<25>(), o.zone); - o.via.array.ptr[26] = msgpack::object(v.template get<26>(), o.zone); - o.via.array.ptr[27] = msgpack::object(v.template get<27>(), o.zone); - o.via.array.ptr[28] = msgpack::object(v.template get<28>(), o.zone); - o.via.array.ptr[29] = msgpack::object(v.template get<29>(), o.zone); - o.via.array.ptr[30] = msgpack::object(v.template get<30>(), o.zone); - o.via.array.ptr[31] = msgpack::object(v.template get<31>(), o.zone); - } -}; - -/// @endcond - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_CPP03_MSGPACK_TUPLE_HPP diff --git a/deps/msgpack/msgpack/adaptor/detail/cpp11_define.hpp b/deps/msgpack/msgpack/adaptor/detail/cpp11_define.hpp deleted file mode 100644 index 115018f..0000000 --- a/deps/msgpack/msgpack/adaptor/detail/cpp11_define.hpp +++ /dev/null @@ -1,199 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CPP11_DEFINE_HPP -#define MSGPACK_CPP11_DEFINE_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" - -// for MSGPACK_ADD_ENUM -#include "msgpack/adaptor/int.hpp" - -#include -#include - -#define MSGPACK_DEFINE(...) \ - template \ - void msgpack_pack(Packer& pk) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_pack(pk); \ - } \ - void msgpack_unpack(msgpack::object const& o) \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_unpack(o); \ - }\ - template \ - void msgpack_object(MSGPACK_OBJECT* o, msgpack::zone& z) const \ - { \ - msgpack::type::make_define(__VA_ARGS__).msgpack_object(o, z); \ - } - -// MSGPACK_ADD_ENUM must be used in the global namespace. -#define MSGPACK_ADD_ENUM(enum_name) \ - namespace msgpack { \ - /** @cond */ \ - MSGPACK_API_VERSION_NAMESPACE(v1) { \ - /** @endcond */ \ - namespace adaptor { \ - template<> \ - struct convert { \ - msgpack::object const& operator()(msgpack::object const& o, enum_name& v) const { \ - std::underlying_type::type tmp; \ - o >> tmp; \ - v = static_cast(tmp); \ - return o; \ - } \ - }; \ - template<> \ - struct object { \ - void operator()(msgpack::object& o, const enum_name& v) const { \ - auto tmp = static_cast::type>(v); \ - o << tmp; \ - } \ - }; \ - template<> \ - struct object_with_zone { \ - void operator()(msgpack::object::with_zone& o, const enum_name& v) const { \ - auto tmp = static_cast::type>(v); \ - o << tmp; \ - } \ - }; \ - template <> \ - struct pack { \ - template \ - msgpack::packer& operator()(msgpack::packer& o, const enum_name& v) const { \ - return o << static_cast::type>(v); \ - } \ - }; \ - } \ - /** @cond */ \ - } \ - /** @endcond */ \ - } - -namespace msgpack { -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond -namespace type { - -template -struct define_imp { - template - static void pack(Packer& pk, Tuple const& t) { - define_imp::pack(pk, t); - pk.pack(std::get(t)); - } - static void unpack(msgpack::object const& o, Tuple& t) { - define_imp::unpack(o, t); - const size_t size = o.via.array.size; - if(size <= N-1) { return; } - o.via.array.ptr[N-1].convert(std::get(t)); - } - static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) { - define_imp::object(o, z, t); - o->via.array.ptr[N-1] = msgpack::object(std::get(t), z); - } -}; - -template -struct define_imp { - template - static void pack(Packer& pk, Tuple const& t) { - pk.pack(std::get<0>(t)); - } - static void unpack(msgpack::object const& o, Tuple& t) { - const size_t size = o.via.array.size; - if(size <= 0) { return; } - o.via.array.ptr[0].convert(std::get<0>(t)); - } - static void object(msgpack::object* o, msgpack::zone& z, Tuple const& t) { - o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z); - } -}; - -template -struct define { - typedef define value_type; - typedef std::tuple tuple_type; - define(Args&... args) : - a(args...) {} - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(sizeof...(Args)); - - define_imp, sizeof...(Args)>::pack(pk, a); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - - define_imp, sizeof...(Args)>::unpack(o, a); - } - void msgpack_object(msgpack::object* o, msgpack::zone& z) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = static_cast(z.allocate_align(sizeof(msgpack::object)*sizeof...(Args))); - o->via.array.size = sizeof...(Args); - - define_imp, sizeof...(Args)>::object(o, z, a); - } - - std::tuple a; -}; - -template <> -struct define<> { - typedef define<> value_type; - typedef std::tuple<> tuple_type; - template - void msgpack_pack(Packer& pk) const - { - pk.pack_array(0); - } - void msgpack_unpack(msgpack::object const& o) - { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - } - void msgpack_object(msgpack::object* o, msgpack::zone&) const - { - o->type = msgpack::type::ARRAY; - o->via.array.ptr = NULL; - o->via.array.size = 0; - } -}; - -inline define<> make_define() -{ - return define<>(); -} - -template -define make_define(Args&... args) -{ - return define(args...); -} - -} // namespace type -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond -} // namespace msgpack - -#endif // MSGPACK_CPP11_DEFINE_HPP diff --git a/deps/msgpack/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp b/deps/msgpack/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp deleted file mode 100644 index 88e57c0..0000000 --- a/deps/msgpack/msgpack/adaptor/detail/cpp11_msgpack_tuple.hpp +++ /dev/null @@ -1,235 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CPP11_MSGPACK_TUPLE_HPP -#define MSGPACK_CPP11_MSGPACK_TUPLE_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/object_fwd.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace type { - // tuple - using std::get; - using std::tuple_size; - using std::tuple_element; - using std::uses_allocator; - using std::ignore; - using std::make_tuple; - using std::tie; - using std::forward_as_tuple; - using std::swap; - - template< class... Types > - class tuple : public std::tuple { - public: - using base = std::tuple; - - using base::base; - - tuple() = default; - tuple(tuple const&) = default; - tuple(tuple&&) = default; - - template - tuple(tuple const& other):base(static_cast const&>(other)) {} - template - tuple(tuple && other):base(static_cast &&>(other)) {} - - tuple& operator=(tuple const&) = default; - tuple& operator=(tuple&&) = default; - - template - tuple& operator=(tuple const& other) { - *static_cast(this) = static_cast const&>(other); - return *this; - } - template - tuple& operator=(tuple && other) { - *static_cast(this) = static_cast &&>(other); - return *this; - } - - template< std::size_t I> - typename tuple_element::type& - get() { return std::get(*this); } - - template< std::size_t I> - typename tuple_element::type const& - get() const { return std::get(*this); } - - template< std::size_t I> - typename tuple_element::type&& - get() && { return std::get(*this); } - }; - - template< class... Tuples > - auto tuple_cat(Tuples&&... args) -> - decltype( - std::tuple_cat(std::forward::type::base>(args)...) - ) { - return std::tuple_cat(std::forward::type::base>(args)...); - } -} // namespace type - -// --- Pack from tuple to packer stream --- -template -struct MsgpackTuplePacker { - static void pack( - msgpack::packer& o, - const Tuple& v) { - MsgpackTuplePacker::pack(o, v); - o.pack(type::get(v)); - } -}; - -template -struct MsgpackTuplePacker { - static void pack ( - msgpack::packer& o, - const Tuple& v) { - o.pack(type::get<0>(v)); - } -}; - -template -struct MsgpackTuplePacker { - static void pack ( - msgpack::packer&, - const Tuple&) { - } -}; - -namespace adaptor { - -template -struct pack> { - template - msgpack::packer& operator()( - msgpack::packer& o, - const type::tuple& v) const { - o.pack_array(sizeof...(Args)); - MsgpackTuplePacker::pack(o, v); - return o; - } -}; - -} // namespace adaptor - -// --- Convert from tuple to object --- - -template -struct MsgpackTupleConverter { - static void convert( - msgpack::object const& o, - Tuple& v) { - MsgpackTupleConverter::convert(o, v); - o.via.array.ptr[N-1].convert(v))>::type>(type::get(v)); - } -}; - -template -struct MsgpackTupleConverter { - static void convert ( - msgpack::object const& o, - Tuple& v) { - o.via.array.ptr[0].convert(v))>::type>(type::get<0>(v)); - } -}; - -template -struct MsgpackTupleConverter { - static void convert ( - msgpack::object const&, - Tuple&) { - } -}; - -namespace adaptor { - -template -struct convert> { - msgpack::object const& operator()( - msgpack::object const& o, - type::tuple& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size < sizeof...(Args)) { throw msgpack::type_error(); } - MsgpackTupleConverter::convert(o, v); - return o; - } -}; - -} // namespace adaptor - -// --- Convert from tuple to object with zone --- -template -struct MsgpackTupleToObjectWithZone { - static void convert( - msgpack::object::with_zone& o, - const Tuple& v) { - MsgpackTupleToObjectWithZone::convert(o, v); - o.via.array.ptr[N-1] = msgpack::object(type::get(v), o.zone); - } -}; - -template -struct MsgpackTupleToObjectWithZone { - static void convert ( - msgpack::object::with_zone& o, - const Tuple& v) { - o.via.array.ptr[0] = msgpack::object(type::get<0>(v), o.zone); - } -}; - -template -struct MsgpackTupleToObjectWithZone { - static void convert ( - msgpack::object::with_zone&, - const Tuple&) { - } -}; - -namespace adaptor { - -template - struct object_with_zone> { - void operator()( - msgpack::object::with_zone& o, - type::tuple const& v) const { - o.type = msgpack::type::ARRAY; - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*sizeof...(Args))); - o.via.array.size = sizeof...(Args); - MsgpackTupleToObjectWithZone::convert(o, v); - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -///@endcond - -} // namespace msgpack - -#endif // MSGPACK_CPP11_MSGPACK_TUPLE_HPP diff --git a/deps/msgpack/msgpack/adaptor/fixint.hpp b/deps/msgpack/msgpack/adaptor/fixint.hpp deleted file mode 100644 index 31bd0cd..0000000 --- a/deps/msgpack/msgpack/adaptor/fixint.hpp +++ /dev/null @@ -1,306 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2020 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_FIXINT_HPP -#define MSGPACK_TYPE_FIXINT_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/int.hpp" - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace type { - - -template -struct fix_int { - fix_int() : value(0) { } - fix_int(T value) : value(value) { } - - operator T() const { return value; } - - T get() const { return value; } - -private: - T value; -}; - - -typedef fix_int fix_uint8; -typedef fix_int fix_uint16; -typedef fix_int fix_uint32; -typedef fix_int fix_uint64; - -typedef fix_int fix_int8; -typedef fix_int fix_int16; -typedef fix_int fix_int32; -typedef fix_int fix_int64; - - -} // namespace type - -namespace adaptor { - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::fix_int8& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::fix_int16& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::fix_int32& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::fix_int64& v) const - { v = type::detail::convert_integer(o); return o; } -}; - - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::fix_uint8& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::fix_uint16& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::fix_uint32& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::fix_uint64& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::fix_int8& v) const - { o.pack_fix_int8(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::fix_int16& v) const - { o.pack_fix_int16(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::fix_int32& v) const - { o.pack_fix_int32(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::fix_int64& v) const - { o.pack_fix_int64(v); return o; } -}; - - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::fix_uint8& v) const - { o.pack_fix_uint8(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::fix_uint16& v) const - { o.pack_fix_uint16(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::fix_uint32& v) const - { o.pack_fix_uint32(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::fix_uint64& v) const - { o.pack_fix_uint64(v); return o; } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::fix_int8 v) const { - if (v.get() < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v.get(); - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v.get(); - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::fix_int16 v) const { - if(v.get() < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v.get(); - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v.get(); - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::fix_int32 v) const { - if (v.get() < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v.get(); - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v.get(); - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::fix_int64 v) const { - if (v.get() < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v.get(); - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v.get(); - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::fix_uint8 v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::fix_uint16 v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::fix_uint32 v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::fix_uint64 v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v.get(); } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::fix_int8 v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::fix_int16 v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::fix_int32 v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::fix_int64 v) const - { static_cast(o) << v; } -}; - - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::fix_uint8 v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::fix_uint16 v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::fix_uint32 v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::fix_uint64 v) const - { static_cast(o) << v; } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif /* msgpack/type/fixint.hpp */ diff --git a/deps/msgpack/msgpack/adaptor/float.hpp b/deps/msgpack/msgpack/adaptor/float.hpp deleted file mode 100644 index c48a214..0000000 --- a/deps/msgpack/msgpack/adaptor/float.hpp +++ /dev/null @@ -1,131 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_FLOAT_HPP -#define MSGPACK_TYPE_FLOAT_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/object_fwd.hpp" -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -// FIXME check overflow, underflow - -namespace adaptor { - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, float& v) const { - if(o.type == msgpack::type::FLOAT) { - v = static_cast(o.via.f64); - } - else if (o.type == msgpack::type::POSITIVE_INTEGER) { - v = static_cast(o.via.u64); - } - else if (o.type == msgpack::type::NEGATIVE_INTEGER) { - v = static_cast(o.via.i64); - } - else { - throw msgpack::type_error(); - } - return o; - } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const float& v) const { - o.pack_float(v); - return o; - } -}; - - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, double& v) const { - if(o.type == msgpack::type::FLOAT) { - v = o.via.f64; - } - else if (o.type == msgpack::type::POSITIVE_INTEGER) { - v = static_cast(o.via.u64); - } - else if (o.type == msgpack::type::NEGATIVE_INTEGER) { - v = static_cast(o.via.i64); - } - else { - throw msgpack::type_error(); - } - return o; - } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const double& v) const { - o.pack_double(v); - return o; - } -}; - - -template <> -struct object { - void operator()(msgpack::object& o, float v) const { - o.type = msgpack::type::FLOAT; - o.via.f64 = static_cast(v); - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, double v) const { - o.type = msgpack::type::FLOAT; - o.via.f64 = v; - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, float v) const { - static_cast(o) << v; - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, double v) const { - static_cast(o) << v; - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_FLOAT_HPP diff --git a/deps/msgpack/msgpack/adaptor/int.hpp b/deps/msgpack/msgpack/adaptor/int.hpp deleted file mode 100644 index c605b24..0000000 --- a/deps/msgpack/msgpack/adaptor/int.hpp +++ /dev/null @@ -1,436 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_INT_HPP -#define MSGPACK_TYPE_INT_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1){ -/// @endcond - -namespace type { -namespace detail { - template - struct convert_integer_sign; - - template - struct convert_integer_sign { - static inline T convert(msgpack::object const& o) { - if(o.type == msgpack::type::POSITIVE_INTEGER) { - if(o.via.u64 > static_cast(std::numeric_limits::max())) - { throw msgpack::type_error(); } - return static_cast(o.via.u64); - } else if(o.type == msgpack::type::NEGATIVE_INTEGER) { - if(o.via.i64 < static_cast(std::numeric_limits::min())) - { throw msgpack::type_error(); } - return static_cast(o.via.i64); - } - throw msgpack::type_error(); - } - }; - - template - struct convert_integer_sign { - static inline T convert(msgpack::object const& o) { - if(o.type == msgpack::type::POSITIVE_INTEGER) { - if(o.via.u64 > static_cast(std::numeric_limits::max())) - { throw msgpack::type_error(); } - return static_cast(o.via.u64); - } - throw msgpack::type_error(); - } - }; - - template - struct is_signed { - static const bool value = std::numeric_limits::is_signed; - }; - - template - static inline T convert_integer(msgpack::object const& o) - { - return detail::convert_integer_sign::value>::convert(o); - } - - template - struct object_char_sign; - - template <> - struct object_char_sign { - static inline void make(msgpack::object& o, char v) { - if (v < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v; - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v; - } - } - }; - - template <> - struct object_char_sign { - static inline void make(msgpack::object& o, char v) { - o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; - } - }; - - static inline void object_char(msgpack::object& o, char v) { - return object_char_sign::value>::make(o, v); - } - -} // namespace detail -} // namespace type - -namespace adaptor { - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, char& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, signed char& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, signed short& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, signed int& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, signed long& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, signed long long& v) const - { v = type::detail::convert_integer(o); return o; } -}; - - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, unsigned char& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, unsigned short& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, unsigned int& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, unsigned long& v) const - { v = type::detail::convert_integer(o); return o; } -}; - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, unsigned long long& v) const - { v = type::detail::convert_integer(o); return o; } -}; - - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, char v) const - { o.pack_char(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, signed char v) const - { o.pack_signed_char(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, signed short v) const - { o.pack_short(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, signed int v) const - { o.pack_int(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, signed long v) const - { o.pack_long(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, signed long long v) const - { o.pack_long_long(v); return o; } -}; - - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, unsigned char v) const - { o.pack_unsigned_char(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, unsigned short v) const - { o.pack_unsigned_short(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, unsigned int v) const - { o.pack_unsigned_int(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, unsigned long v) const - { o.pack_unsigned_long(v); return o; } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, unsigned long long v) const - { o.pack_unsigned_long_long(v); return o; } -}; - - -template <> -struct object { - void operator()(msgpack::object& o, char v) const - { type::detail::object_char(o, v); } -}; - -template <> -struct object { - void operator()(msgpack::object& o, signed char v) const { - if (v < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v; - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v; - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, signed short v) const { - if (v < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v; - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v; - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, signed int v) const { - if (v < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v; - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v; - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, signed long v) const { - if (v < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v; - } - else { - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v; - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, signed long long v) const { - if (v < 0) { - o.type = msgpack::type::NEGATIVE_INTEGER; - o.via.i64 = v; - } - else{ - o.type = msgpack::type::POSITIVE_INTEGER; - o.via.u64 = v; - } - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, unsigned char v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } -}; - -template <> -struct object { - void operator()(msgpack::object& o, unsigned short v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } -}; - -template <> -struct object { - void operator()(msgpack::object& o, unsigned int v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } -}; - -template <> -struct object { - void operator()(msgpack::object& o, unsigned long v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } -}; - -template <> -struct object { - void operator()(msgpack::object& o, unsigned long long v) const - { o.type = msgpack::type::POSITIVE_INTEGER, o.via.u64 = v; } -}; - - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, char v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, signed char v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, signed short v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, signed int v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, signed long v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const signed long long& v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, unsigned char v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, unsigned short v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, unsigned int v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, unsigned long v) const - { static_cast(o) << v; } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const unsigned long long& v) const - { static_cast(o) << v; } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif /* msgpack/type/int.hpp */ diff --git a/deps/msgpack/msgpack/adaptor/list.hpp b/deps/msgpack/msgpack/adaptor/list.hpp deleted file mode 100644 index 2df460c..0000000 --- a/deps/msgpack/msgpack/adaptor/list.hpp +++ /dev/null @@ -1,95 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_LIST_HPP -#define MSGPACK_TYPE_LIST_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::list& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - v.resize(o.via.array.size); - msgpack::object* p = o.via.array.ptr; - msgpack::object* const pend = o.via.array.ptr + o.via.array.size; - typename std::list::iterator it = v.begin(); - for(; p < pend; ++p, ++it) { - p->convert(*it); - } - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::list& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename std::list::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::list& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename std::list::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_LIST_HPP diff --git a/deps/msgpack/msgpack/adaptor/map.hpp b/deps/msgpack/msgpack/adaptor/map.hpp deleted file mode 100644 index 4cf7821..0000000 --- a/deps/msgpack/msgpack/adaptor/map.hpp +++ /dev/null @@ -1,237 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_MAP_HPP -#define MSGPACK_TYPE_MAP_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/object_fwd.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include -#include -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace type { - -template -class assoc_vector : public std::vector< std::pair > {}; - -namespace detail { - template - struct pair_first_less { - bool operator() (const std::pair& x, const std::pair& y) const - { return x.first < y.first; } - }; -} - -} //namespace type - -namespace adaptor { - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, type::assoc_vector& v) const { - if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } - v.resize(o.via.map.size); - msgpack::object_kv* p = o.via.map.ptr; - msgpack::object_kv* const pend = o.via.map.ptr + o.via.map.size; - std::pair* it(&v.front()); - for(; p < pend; ++p, ++it) { - p->key.convert(it->first); - p->val.convert(it->second); - } - std::sort(v.begin(), v.end(), type::detail::pair_first_less()); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const type::assoc_vector& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_map(size); - for(typename type::assoc_vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const type::assoc_vector& v) const { - o.type = msgpack::type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object_kv* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object_kv)*size)); - msgpack::object_kv* const pend = p + size; - o.via.map.ptr = p; - o.via.map.size = size; - typename type::assoc_vector::const_iterator it(v.begin()); - do { - p->key = msgpack::object(it->first, o.zone); - p->val = msgpack::object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::map& v) const { - if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } - msgpack::object_kv* p(o.via.map.ptr); - msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::map tmp; - for(; p != pend; ++p) { - K key; - p->key.convert(key); - typename std::map::iterator it(tmp.lower_bound(key)); - if(it != tmp.end() && !(key < it->first)) { - p->val.convert(it->second); - } else { - V val; - p->val.convert(val); - tmp.insert(it, std::pair(key, val)); - } - } - tmp.swap(v); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::map& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_map(size); - for(typename std::map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::map& v) const { - o.type = msgpack::type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object_kv* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object_kv)*size)); - msgpack::object_kv* const pend = p + size; - o.via.map.ptr = p; - o.via.map.size = size; - typename std::map::const_iterator it(v.begin()); - do { - p->key = msgpack::object(it->first, o.zone); - p->val = msgpack::object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::multimap& v) const { - if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } - msgpack::object_kv* p(o.via.map.ptr); - msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - std::multimap tmp; - for(; p != pend; ++p) { - std::pair value; - p->key.convert(value.first); - p->val.convert(value.second); - tmp.insert(value); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::multimap& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_map(size); - for(typename std::multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::multimap& v) const { - o.type = msgpack::type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object_kv* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object_kv)*size)); - msgpack::object_kv* const pend = p + size; - o.via.map.ptr = p; - o.via.map.size = size; - typename std::multimap::const_iterator it(v.begin()); - do { - p->key = msgpack::object(it->first, o.zone); - p->val = msgpack::object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_MAP_HPP diff --git a/deps/msgpack/msgpack/adaptor/msgpack_tuple.hpp b/deps/msgpack/msgpack/adaptor/msgpack_tuple.hpp deleted file mode 100644 index 57fd4ba..0000000 --- a/deps/msgpack/msgpack/adaptor/msgpack_tuple.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_MSGPACK_TUPLE_HPP -#define MSGPACK_MSGPACK_TUPLE_HPP - -#include "msgpack/cpp_config.hpp" - -#if defined(MSGPACK_USE_CPP03) -#include "detail/cpp03_msgpack_tuple.hpp" -#else // MSGPACK_USE_CPP03 -#include "detail/cpp11_msgpack_tuple.hpp" -#endif // MSGPACK_USE_CPP03 - -#endif // MSGPACK_MSGPACK_TUPLE_HPP diff --git a/deps/msgpack/msgpack/adaptor/nil.hpp b/deps/msgpack/msgpack/adaptor/nil.hpp deleted file mode 100644 index 2f99f1a..0000000 --- a/deps/msgpack/msgpack/adaptor/nil.hpp +++ /dev/null @@ -1,84 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_NIL_HPP -#define MSGPACK_TYPE_NIL_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace type { - -struct nil { }; - -} // namespace type - -namespace adaptor { - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, type::nil&) const { - if(o.type != msgpack::type::NIL) { throw msgpack::type_error(); } - return o; - } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const type::nil&) const { - o.pack_nil(); - return o; - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, type::nil) const { - o.type = msgpack::type::NIL; - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, type::nil v) const { - static_cast(o) << v; - } -}; - -} // namespace adaptror - -template <> -inline void msgpack::object::as() const -{ - msgpack::type::nil v; - convert(v); -} - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_NIL_HPP diff --git a/deps/msgpack/msgpack/adaptor/pair.hpp b/deps/msgpack/msgpack/adaptor/pair.hpp deleted file mode 100644 index f7a6784..0000000 --- a/deps/msgpack/msgpack/adaptor/pair.hpp +++ /dev/null @@ -1,75 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_PAIR_HPP -#define MSGPACK_TYPE_PAIR_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::pair& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if(o.via.array.size != 2) { throw msgpack::type_error(); } - o.via.array.ptr[0].convert(v.first); - o.via.array.ptr[1].convert(v.second); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::pair& v) const { - o.pack_array(2); - o.pack(v.first); - o.pack(v.second); - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::pair& v) const { - o.type = msgpack::type::ARRAY; - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*2)); - o.via.array.ptr = p; - o.via.array.size = 2; - p[0] = msgpack::object(v.first, o.zone); - p[1] = msgpack::object(v.second, o.zone); - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_PAIR_HPP diff --git a/deps/msgpack/msgpack/adaptor/raw.hpp b/deps/msgpack/msgpack/adaptor/raw.hpp deleted file mode 100644 index 6e07275..0000000 --- a/deps/msgpack/msgpack/adaptor/raw.hpp +++ /dev/null @@ -1,114 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_RAW_HPP -#define MSGPACK_TYPE_RAW_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace type { - -struct raw_ref { - raw_ref() : size(0), ptr(nullptr) {} - raw_ref(const char* p, uint32_t s) : size(s), ptr(p) {} - - uint32_t size; - const char* ptr; - - std::string str() const { return std::string(ptr, size); } - - bool operator== (const raw_ref& x) const - { - return size == x.size && std::memcmp(ptr, x.ptr, size) == 0; - } - - bool operator!= (const raw_ref& x) const - { - return !(*this != x); - } - - bool operator< (const raw_ref& x) const - { - if(size == x.size) { return std::memcmp(ptr, x.ptr, size) < 0; } - else { return size < x.size; } - } - - bool operator> (const raw_ref& x) const - { - if(size == x.size) { return std::memcmp(ptr, x.ptr, size) > 0; } - else { return size > x.size; } - } -}; - -} // namespace type - -namespace adaptor { - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, msgpack::type::raw_ref& v) const { - if(o.type != msgpack::type::BIN) { throw msgpack::type_error(); } - v.ptr = o.via.bin.ptr; - v.size = o.via.bin.size; - return o; - } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const msgpack::type::raw_ref& v) const { - o.pack_bin(v.size); - o.pack_bin_body(v.ptr, v.size); - return o; - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, const msgpack::type::raw_ref& v) const { - o.type = msgpack::type::BIN; - o.via.bin.ptr = v.ptr; - o.via.bin.size = v.size; - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const msgpack::type::raw_ref& v) const { - static_cast(o) << v; - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_RAW_HPP diff --git a/deps/msgpack/msgpack/adaptor/set.hpp b/deps/msgpack/msgpack/adaptor/set.hpp deleted file mode 100644 index c44b0b8..0000000 --- a/deps/msgpack/msgpack/adaptor/set.hpp +++ /dev/null @@ -1,149 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_SET_HPP -#define MSGPACK_TYPE_SET_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::set& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - msgpack::object* p = o.via.array.ptr + o.via.array.size; - msgpack::object* const pbegin = o.via.array.ptr; - std::set tmp; - while(p > pbegin) { - --p; - tmp.insert(p->as()); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::set& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename std::set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::set& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename std::set::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::multiset& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - msgpack::object* p = o.via.array.ptr + o.via.array.size; - msgpack::object* const pbegin = o.via.array.ptr; - std::multiset tmp; - while(p > pbegin) { - --p; - tmp.insert(p->as()); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::multiset& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename std::multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::multiset& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename std::multiset::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_SET_HPP diff --git a/deps/msgpack/msgpack/adaptor/string.hpp b/deps/msgpack/msgpack/adaptor/string.hpp deleted file mode 100644 index 4fc5fdd..0000000 --- a/deps/msgpack/msgpack/adaptor/string.hpp +++ /dev/null @@ -1,94 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_STRING_HPP -#define MSGPACK_TYPE_STRING_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, std::string& v) const { - switch (o.type) { - case msgpack::type::BIN: - v.assign(o.via.bin.ptr, o.via.bin.size); - break; - case msgpack::type::STR: - v.assign(o.via.str.ptr, o.via.str.size); - break; - default: - throw msgpack::type_error(); - break; - } - return o; - } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, const std::string& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_str(size); - o.pack_str_body(v.data(), size); - return o; - } -}; - -template <> -struct object { - void operator()(msgpack::object& o, const std::string& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.type = msgpack::type::STR; - o.via.str.ptr = v.data(); - o.via.str.size = size; - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, const std::string& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.type = msgpack::type::STR; - char* ptr = static_cast(o.zone.allocate_align(size)); - o.via.str.ptr = ptr; - o.via.str.size = size; - std::memcpy(ptr, v.data(), v.size()); - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_STRING_HPP diff --git a/deps/msgpack/msgpack/adaptor/tr1/unordered_map.hpp b/deps/msgpack/msgpack/adaptor/tr1/unordered_map.hpp deleted file mode 100644 index 793f4cc..0000000 --- a/deps/msgpack/msgpack/adaptor/tr1/unordered_map.hpp +++ /dev/null @@ -1,179 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP -#define MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#define MSGPACK_HAS_STD_UNORDERED_MAP -#include -#define MSGPACK_STD_TR1 std - -#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#if __GNUC__ >= 4 - -#define MSGPACK_HAS_STD_TR1_UNORDERED_MAP - -#include -#define MSGPACK_STD_TR1 std::tr1 - -#endif // __GNUC__ >= 4 - -#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#if defined(MSGPACK_STD_TR1) - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_map& v) const { - if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } - msgpack::object_kv* p(o.via.map.ptr); - msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - MSGPACK_STD_TR1::unordered_map tmp; - for(; p != pend; ++p) { - K key; - p->key.convert(key); - p->val.convert(tmp[key]); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_map& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_map(size); - for(typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_map& v) const { - o.type = msgpack::type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object_kv* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object_kv)*size)); - msgpack::object_kv* const pend = p + size; - o.via.map.ptr = p; - o.via.map.size = size; - typename MSGPACK_STD_TR1::unordered_map::const_iterator it(v.begin()); - do { - p->key = msgpack::object(it->first, o.zone); - p->val = msgpack::object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multimap& v) const { - if(o.type != msgpack::type::MAP) { throw msgpack::type_error(); } - msgpack::object_kv* p(o.via.map.ptr); - msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - MSGPACK_STD_TR1::unordered_multimap tmp; - for(; p != pend; ++p) { - std::pair value; - p->key.convert(value.first); - p->val.convert(value.second); - tmp.insert(value); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_multimap& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_map(size); - for(typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(it->first); - o.pack(it->second); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multimap& v) const { - o.type = msgpack::type::MAP; - if(v.empty()) { - o.via.map.ptr = nullptr; - o.via.map.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object_kv* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object_kv)*size)); - msgpack::object_kv* const pend = p + size; - o.via.map.ptr = p; - o.via.map.size = size; - typename MSGPACK_STD_TR1::unordered_multimap::const_iterator it(v.begin()); - do { - p->key = msgpack::object(it->first, o.zone); - p->val = msgpack::object(it->second, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#undef MSGPACK_STD_TR1 - -#endif // MSGPACK_STD_TR1 - -#endif // MSGPACK_TYPE_TR1_UNORDERED_MAP_HPP diff --git a/deps/msgpack/msgpack/adaptor/tr1/unordered_set.hpp b/deps/msgpack/msgpack/adaptor/tr1/unordered_set.hpp deleted file mode 100644 index 6512ac3..0000000 --- a/deps/msgpack/msgpack/adaptor/tr1/unordered_set.hpp +++ /dev/null @@ -1,173 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_TR1_UNORDERED_SET_HPP -#define MSGPACK_TYPE_TR1_UNORDERED_SET_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#if defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#define MSGPACK_HAS_STD_UNORDERED_SET -#include -#define MSGPACK_STD_TR1 std - -#else // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#if __GNUC__ >= 4 - -#define MSGPACK_HAS_STD_TR1_UNORDERED_SET - -#include -#define MSGPACK_STD_TR1 std::tr1 - -#endif // __GNUC__ >= 4 - -#endif // defined(_LIBCPP_VERSION) || (_MSC_VER >= 1700) - -#if defined(MSGPACK_STD_TR1) - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_set& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - msgpack::object* p = o.via.array.ptr + o.via.array.size; - msgpack::object* const pbegin = o.via.array.ptr; - MSGPACK_STD_TR1::unordered_set tmp; - while(p > pbegin) { - --p; - tmp.insert(p->as()); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_set& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_set& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename MSGPACK_STD_TR1::unordered_set::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, MSGPACK_STD_TR1::unordered_multiset& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - msgpack::object* p = o.via.array.ptr + o.via.array.size; - msgpack::object* const pbegin = o.via.array.ptr; - MSGPACK_STD_TR1::unordered_multiset tmp; - while(p > pbegin) { - --p; - tmp.insert(p->as()); - } - tmp.swap(v); - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const MSGPACK_STD_TR1::unordered_multiset& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const MSGPACK_STD_TR1::unordered_multiset& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename MSGPACK_STD_TR1::unordered_multiset::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#undef MSGPACK_STD_TR1 - -#endif // MSGPACK_STD_TR1 - -#endif // MSGPACK_TYPE_TR1_UNORDERED_SET_HPP diff --git a/deps/msgpack/msgpack/adaptor/vector.hpp b/deps/msgpack/msgpack/adaptor/vector.hpp deleted file mode 100644 index 9810304..0000000 --- a/deps/msgpack/msgpack/adaptor/vector.hpp +++ /dev/null @@ -1,99 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2009 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_VECTOR_HPP -#define MSGPACK_TYPE_VECTOR_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { - if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - v.resize(o.via.array.size); - if(o.via.array.size > 0) { - msgpack::object* p = o.via.array.ptr; - msgpack::object* const pend = o.via.array.ptr + o.via.array.size; - typename std::vector::iterator it = v.begin(); - do { - p->convert(*it); - ++p; - ++it; - } while(p < pend); - } - return o; - } -}; - -template -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(typename std::vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(*it); - } - return o; - } -}; - -template -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::vector& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - typename std::vector::const_iterator it(v.begin()); - do { - *p = msgpack::object(*it, o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_VECTOR_HPP diff --git a/deps/msgpack/msgpack/adaptor/vector_bool.hpp b/deps/msgpack/msgpack/adaptor/vector_bool.hpp deleted file mode 100644 index 516c552..0000000 --- a/deps/msgpack/msgpack/adaptor/vector_bool.hpp +++ /dev/null @@ -1,96 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_VECTOR_BOOL_HPP -#define MSGPACK_TYPE_VECTOR_BOOL_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/object_fwd.hpp" -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template <> -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { - if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); } - if (o.via.array.size > 0) { - v.resize(o.via.array.size); - msgpack::object* p = o.via.array.ptr; - for (std::vector::iterator it = v.begin(), end = v.end(); - it != end; - ++it) { - *it = p->as(); - ++p; - } - } - return o; - } -}; - -template <> -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_array(size); - for(std::vector::const_iterator it(v.begin()), it_end(v.end()); - it != it_end; ++it) { - o.pack(static_cast(*it)); - } - return o; - } -}; - -template <> -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::vector& v) const { - o.type = msgpack::type::ARRAY; - if(v.empty()) { - o.via.array.ptr = nullptr; - o.via.array.size = 0; - } else { - uint32_t size = checked_get_container_size(v.size()); - msgpack::object* p = static_cast(o.zone.allocate_align(sizeof(msgpack::object)*size)); - msgpack::object* const pend = p + size; - o.via.array.ptr = p; - o.via.array.size = size; - std::vector::const_iterator it(v.begin()); - do { - *p = msgpack::object(static_cast(*it), o.zone); - ++p; - ++it; - } while(p < pend); - } - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_VECTOR_BOOL_HPP diff --git a/deps/msgpack/msgpack/adaptor/vector_char.hpp b/deps/msgpack/msgpack/adaptor/vector_char.hpp deleted file mode 100644 index f59a0ef..0000000 --- a/deps/msgpack/msgpack/adaptor/vector_char.hpp +++ /dev/null @@ -1,97 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2014-2015 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_TYPE_VECTOR_CHAR_HPP -#define MSGPACK_TYPE_VECTOR_CHAR_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" -#include "msgpack/adaptor/check_container_size.hpp" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace adaptor { - -template <> -struct convert > { - msgpack::object const& operator()(msgpack::object const& o, std::vector& v) const { - switch (o.type) { - case msgpack::type::BIN: - v.resize(o.via.bin.size); - std::memcpy(&v.front(), o.via.bin.ptr, o.via.bin.size); - break; - case msgpack::type::STR: - v.resize(o.via.str.size); - std::memcpy(&v.front(), o.via.str.ptr, o.via.str.size); - break; - default: - throw msgpack::type_error(); - break; - } - return o; - } -}; - -template <> -struct pack > { - template - msgpack::packer& operator()(msgpack::packer& o, const std::vector& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.pack_bin(size); - o.pack_bin_body(&v.front(), size); - - return o; - } -}; - -template <> -struct object > { - void operator()(msgpack::object& o, const std::vector& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.type = msgpack::type::BIN; - o.via.bin.ptr = &v.front(); - o.via.bin.size = size; - } -}; - -template <> -struct object_with_zone > { - void operator()(msgpack::object::with_zone& o, const std::vector& v) const { - uint32_t size = checked_get_container_size(v.size()); - o.type = msgpack::type::BIN; - char* ptr = static_cast(o.zone.allocate_align(size)); - o.via.bin.ptr = ptr; - o.via.bin.size = size; - std::memcpy(ptr, &v.front(), size); - } -}; - -} // namespace adaptor - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_TYPE_VECTOR_CHAR_HPP diff --git a/deps/msgpack/msgpack/cpp_config.hpp b/deps/msgpack/msgpack/cpp_config.hpp deleted file mode 100644 index f9cf3f3..0000000 --- a/deps/msgpack/msgpack/cpp_config.hpp +++ /dev/null @@ -1,117 +0,0 @@ -// -// MessagePack for C++ C++03/C++11 Adaptation -// -// Copyright (C) 2013 KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CPP_CONFIG_HPP -#define MSGPACK_CPP_CONFIG_HPP - -#include "msgpack/versioning.hpp" - -#if !defined(MSGPACK_USE_CPP03) - // If MSVC would support C++11 completely, - // then 'defined(_MSC_VER)' would replace with - // '_MSC_VER < XXXX' -# if (__cplusplus < 201103) || defined(_MSC_VER) -# define MSGPACK_USE_CPP03 -# endif -#endif // MSGPACK_USE_CPP03 - - - -#if defined __cplusplus -#if __cplusplus < 201103 - -#if !defined(nullptr) -# if _MSC_VER < 1600 -# define nullptr (0) -# endif -#endif - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -template -struct unique_ptr : std::auto_ptr { - explicit unique_ptr(T* p = 0) throw() : std::auto_ptr(p) {} - unique_ptr(unique_ptr& a) throw() : std::auto_ptr(a) {} - template - unique_ptr (unique_ptr& a) throw() : std::auto_ptr(a) {} -}; - -template -T& move(T& t) -{ - return t; -} - -template -T const& move(T const& t) -{ - return t; -} - -template -struct enable_if { - typedef T type; -}; - -template -struct enable_if { -}; - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - - -#else // __cplusplus < 201103 - -#include -#include - -namespace msgpack { -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - - // unique_ptr - using std::unique_ptr; - // using std::make_unique; // since C++14 - using std::hash; - - // utility - using std::move; - using std::swap; - using std::enable_if; - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond -} // namespace msgpack - - -#endif // __cplusplus < 201103 - -#endif // __cplusplus - -#endif /* msgpack/cpp_config.hpp */ diff --git a/deps/msgpack/msgpack/detail/cpp03_zone.hpp b/deps/msgpack/msgpack/detail/cpp03_zone.hpp deleted file mode 100644 index 08a2914..0000000 --- a/deps/msgpack/msgpack/detail/cpp03_zone.hpp +++ /dev/null @@ -1,670 +0,0 @@ -// -// MessagePack for C++ memory pool -// -// Copyright (C) 2008-2010 FURUHASHI Sadayuki -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CPP03_ZONE_HPP -#define MSGPACK_CPP03_ZONE_HPP - -#include -#include -#include - -#include "msgpack/versioning.hpp" - -#ifndef MSGPACK_ZONE_CHUNK_SIZE -#define MSGPACK_ZONE_CHUNK_SIZE 8192 -#endif - -#ifndef MSGPACK_ZONE_ALIGN -#define MSGPACK_ZONE_ALIGN sizeof(void*) -#endif - - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -class zone { - struct finalizer { - finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} - void operator()() { m_func(m_data); } - void (*m_func)(void*); - void* m_data; - }; - struct finalizer_array { - finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} - void call() { - finalizer* fin = m_tail; - for(; fin != m_array; --fin) (*(fin-1))(); - } - ~finalizer_array() { - call(); - ::free(m_array); - } - void clear() { - call(); - m_tail = m_array; - } - void push(void (*func)(void* data), void* data) - { - finalizer* fin = m_tail; - - if(fin == m_end) { - push_expand(func, data); - return; - } - - fin->m_func = func; - fin->m_data = data; - - ++m_tail; - } - void push_expand(void (*func)(void*), void* data) { - const size_t nused = m_end - m_array; - size_t nnext; - if(nused == 0) { - nnext = (sizeof(finalizer) < 72/2) ? - 72 / sizeof(finalizer) : 8; - } else { - nnext = nused * 2; - } - finalizer* tmp = - static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); - if(!tmp) { - throw std::bad_alloc(); - } - m_array = tmp; - m_end = tmp + nnext; - m_tail = tmp + nused; - new (m_tail) finalizer(func, data); - - ++m_tail; - } - finalizer* m_tail; - finalizer* m_end; - finalizer* m_array; - }; - struct chunk { - chunk* m_next; - }; - struct chunk_list { - chunk_list(size_t chunk_size) - { - chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); - if(!c) { - throw std::bad_alloc(); - } - - m_head = c; - m_free = chunk_size; - m_ptr = reinterpret_cast(c) + sizeof(chunk); - c->m_next = nullptr; - } - ~chunk_list() - { - chunk* c = m_head; - while(c) { - chunk* n = c->m_next; - ::free(c); - c = n; - } - } - void clear(size_t chunk_size) - { - chunk* c = m_head; - while(true) { - chunk* n = c->m_next; - if(n) { - ::free(c); - c = n; - } else { - break; - } - } - m_head->m_next = nullptr; - m_free = chunk_size; - m_ptr = reinterpret_cast(m_head) + sizeof(chunk); - } - size_t m_free; - char* m_ptr; - chunk* m_head; - }; - size_t m_chunk_size; - chunk_list m_chunk_list; - finalizer_array m_finalizer_array; - -public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) /* throw() */; - -public: - void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN); - void* allocate_no_align(size_t size); - - void push_finalizer(void (*func)(void*), void* data); - - template - void push_finalizer(msgpack::unique_ptr obj); - - void clear(); - - void swap(zone& o); - static void* operator new(std::size_t size) - { - void* p = ::malloc(size); - if (!p) throw std::bad_alloc(); - return p; - } - static void operator delete(void *p) /* throw() */ - { - ::free(p); - } - static void* operator new(std::size_t size, void* place) /* throw() */ - { - return ::operator new(size, place); - } - static void operator delete(void* p, void* place) /* throw() */ - { - ::operator delete(p, place); - } - /// @cond - - template - T* allocate(); - - template - T* allocate(A1 a1); - - template - T* allocate(A1 a1, A2 a2); - - template - T* allocate(A1 a1, A2 a2, A3 a3); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14); - - template - T* allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15); - - /// @endcond - -private: - void undo_allocate(size_t size); - - template - static void object_destruct(void* obj); - - template - static void object_delete(void* obj); - - void* allocate_expand(size_t size); -private: - zone(const zone&); - zone& operator=(const zone&); -}; - -inline zone::zone(size_t chunk_size) /* throw() */ :m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) -{ -} - -inline void* zone::allocate_align(size_t size, size_t align) -{ - char* aligned = - reinterpret_cast( - reinterpret_cast( - (m_chunk_list.m_ptr + (align - 1))) / align * align); - size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr); - if(m_chunk_list.m_free >= adjusted_size) { - m_chunk_list.m_free -= adjusted_size; - m_chunk_list.m_ptr += adjusted_size; - return aligned; - } - return reinterpret_cast( - reinterpret_cast( - allocate_expand(size + (align - 1))) / align * align); -} - -inline void* zone::allocate_no_align(size_t size) -{ - if(m_chunk_list.m_free < size) { - return allocate_expand(size); - } - - char* ptr = m_chunk_list.m_ptr; - m_chunk_list.m_free -= size; - m_chunk_list.m_ptr += size; - - return ptr; -} - -inline void* zone::allocate_expand(size_t size) -{ - chunk_list* const cl = &m_chunk_list; - - size_t sz = m_chunk_size; - - while(sz < size) { - size_t tmp_sz = sz * 2; - if (tmp_sz <= sz) { - sz = size; - break; - } - sz = tmp_sz; - } - - chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - if (!c) throw std::bad_alloc(); - - char* ptr = reinterpret_cast(c) + sizeof(chunk); - - c->m_next = cl->m_head; - cl->m_head = c; - cl->m_free = sz - size; - cl->m_ptr = ptr + size; - - return ptr; -} - -inline void zone::push_finalizer(void (*func)(void*), void* data) -{ - m_finalizer_array.push(func, data); -} - -template -inline void zone::push_finalizer(msgpack::unique_ptr obj) -{ - m_finalizer_array.push(&zone::object_delete, obj.release()); -} - -inline void zone::clear() -{ - m_finalizer_array.clear(); - m_chunk_list.clear(m_chunk_size); -} - -inline void zone::swap(zone& o) -{ - using std::swap; - swap(m_chunk_size, o.m_chunk_size); - swap(m_chunk_list, o.m_chunk_list); - swap(m_finalizer_array, o.m_finalizer_array); -} - -template -void zone::object_destruct(void* obj) -{ - static_cast(obj)->~T(); -} - -template -void zone::object_delete(void* obj) -{ - delete static_cast(obj); -} - -inline void zone::undo_allocate(size_t size) -{ - m_chunk_list.m_ptr -= size; - m_chunk_list.m_free += size; -} - -/// @cond - -template -T* zone::allocate() -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -template -T* zone::allocate(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10, A11 a11, A12 a12, A13 a13, A14 a14, A15 a15) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -/// @endcond - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_CPP03_ZONE_HPP diff --git a/deps/msgpack/msgpack/detail/cpp11_zone.hpp b/deps/msgpack/msgpack/detail/cpp11_zone.hpp deleted file mode 100644 index 4edd843..0000000 --- a/deps/msgpack/msgpack/detail/cpp11_zone.hpp +++ /dev/null @@ -1,372 +0,0 @@ -// -// MessagePack for C++ memory pool -// -// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_CPP11_ZONE_HPP -#define MSGPACK_CPP11_ZONE_HPP - -#include "msgpack/versioning.hpp" - -#include -#include -#include - -#include "msgpack/cpp_config.hpp" - -#ifndef MSGPACK_ZONE_CHUNK_SIZE -#define MSGPACK_ZONE_CHUNK_SIZE 8192 -#endif - -#ifndef MSGPACK_ZONE_ALIGN -#define MSGPACK_ZONE_ALIGN sizeof(void*) -#endif - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -class zone { -private: - struct finalizer { - finalizer(void (*func)(void*), void* data):m_func(func), m_data(data) {} - void operator()() { m_func(m_data); } - void (*m_func)(void*); - void* m_data; - }; - struct finalizer_array { - finalizer_array():m_tail(nullptr), m_end(nullptr), m_array(nullptr) {} - void call() { - finalizer* fin = m_tail; - for(; fin != m_array; --fin) (*(fin-1))(); - } - ~finalizer_array() { - call(); - ::free(m_array); - } - void clear() { - call(); - m_tail = m_array; - } - void push(void (*func)(void* data), void* data) - { - finalizer* fin = m_tail; - - if(fin == m_end) { - push_expand(func, data); - return; - } - - fin->m_func = func; - fin->m_data = data; - - ++m_tail; - } - void push_expand(void (*func)(void*), void* data) { - const size_t nused = m_end - m_array; - size_t nnext; - if(nused == 0) { - nnext = (sizeof(finalizer) < 72/2) ? - 72 / sizeof(finalizer) : 8; - } else { - nnext = nused * 2; - } - finalizer* tmp = - static_cast(::realloc(m_array, sizeof(finalizer) * nnext)); - if(!tmp) { - throw std::bad_alloc(); - } - m_array = tmp; - m_end = tmp + nnext; - m_tail = tmp + nused; - new (m_tail) finalizer(func, data); - - ++m_tail; - } -#if !defined(MSGPACK_USE_CPP03) - finalizer_array(finalizer_array&& other) noexcept - :m_tail(other.m_tail), m_end(other.m_end), m_array(other.m_array) - { - other.m_tail = nullptr; - other.m_end = nullptr; - other.m_array = nullptr; - } - finalizer_array& operator=(finalizer_array&& other) noexcept - { - this->~finalizer_array(); - new (this) finalizer_array(std::move(other)); - return *this; - } -#endif - finalizer* m_tail; - finalizer* m_end; - finalizer* m_array; - - private: - finalizer_array(const finalizer_array&); - finalizer_array& operator=(const finalizer_array&); - }; - struct chunk { - chunk* m_next; - }; - struct chunk_list { - chunk_list(size_t chunk_size) - { - chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); - if(!c) { - throw std::bad_alloc(); - } - - m_head = c; - m_free = chunk_size; - m_ptr = reinterpret_cast(c) + sizeof(chunk); - c->m_next = nullptr; - } - ~chunk_list() - { - chunk* c = m_head; - while(c) { - chunk* n = c->m_next; - ::free(c); - c = n; - } - } - void clear(size_t chunk_size) - { - chunk* c = m_head; - while(true) { - chunk* n = c->m_next; - if(n) { - ::free(c); - c = n; - } else { - m_head = c; - break; - } - } - m_head->m_next = nullptr; - m_free = chunk_size; - m_ptr = reinterpret_cast(m_head) + sizeof(chunk); - } -#if !defined(MSGPACK_USE_CPP03) - chunk_list(chunk_list&& other) noexcept - :m_free(other.m_free), m_ptr(other.m_ptr), m_head(other.m_head) - { - other.m_head = nullptr; - } - chunk_list& operator=(chunk_list&& other) noexcept - { - this->~chunk_list(); - new (this) chunk_list(std::move(other)); - return *this; - } -#endif - size_t m_free; - char* m_ptr; - chunk* m_head; - private: - chunk_list(const chunk_list&); - chunk_list& operator=(const chunk_list&); - }; - size_t m_chunk_size; - chunk_list m_chunk_list; - finalizer_array m_finalizer_array; - -public: - zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE) noexcept; - -public: - void* allocate_align(size_t size, size_t align = MSGPACK_ZONE_ALIGN); - void* allocate_no_align(size_t size); - - void push_finalizer(void (*func)(void*), void* data); - - template - void push_finalizer(msgpack::unique_ptr obj); - - void clear(); - - void swap(zone& o); - - - static void* operator new(std::size_t size) throw(std::bad_alloc) - { - void* p = ::malloc(size); - if (!p) throw std::bad_alloc(); - return p; - } - static void operator delete(void *p) throw() - { - ::free(p); - } - static void* operator new(std::size_t /*size*/, void* mem) throw() - { - return mem; - } - static void operator delete(void * /*p*/, void* /*mem*/) throw() - { - } - - template - T* allocate(Args... args); - - zone(zone&&) = default; - zone& operator=(zone&&) = default; - zone(const zone&) = delete; - zone& operator=(const zone&) = delete; - -private: - void undo_allocate(size_t size); - - template - static void object_destruct(void* obj); - - template - static void object_delete(void* obj); - - void* allocate_expand(size_t size); -}; - -inline zone::zone(size_t chunk_size) noexcept:m_chunk_size(chunk_size), m_chunk_list(m_chunk_size) -{ -} - -inline void* zone::allocate_align(size_t size, size_t align) -{ - char* aligned = - reinterpret_cast( - reinterpret_cast( - (m_chunk_list.m_ptr + (align - 1))) / align * align); - size_t adjusted_size = size + (aligned - m_chunk_list.m_ptr); - if(m_chunk_list.m_free >= adjusted_size) { - m_chunk_list.m_free -= adjusted_size; - m_chunk_list.m_ptr += adjusted_size; - return aligned; - } - return reinterpret_cast( - reinterpret_cast( - allocate_expand(size + (align - 1))) / align * align); -} - -inline void* zone::allocate_no_align(size_t size) -{ - if(m_chunk_list.m_free < size) { - return allocate_expand(size); - } - - char* ptr = m_chunk_list.m_ptr; - m_chunk_list.m_free -= size; - m_chunk_list.m_ptr += size; - - return ptr; -} - -inline void* zone::allocate_expand(size_t size) -{ - chunk_list* const cl = &m_chunk_list; - - size_t sz = m_chunk_size; - - while(sz < size) { - size_t tmp_sz = sz * 2; - if (tmp_sz <= sz) { - sz = size; - break; - } - sz = tmp_sz; - } - - chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - if (!c) throw std::bad_alloc(); - - char* ptr = reinterpret_cast(c) + sizeof(chunk); - - c->m_next = cl->m_head; - cl->m_head = c; - cl->m_free = sz - size; - cl->m_ptr = ptr + size; - - return ptr; -} - -inline void zone::push_finalizer(void (*func)(void*), void* data) -{ - m_finalizer_array.push(func, data); -} - -template -inline void zone::push_finalizer(msgpack::unique_ptr obj) -{ - m_finalizer_array.push(&zone::object_delete, obj.release()); -} - -inline void zone::clear() -{ - m_finalizer_array.clear(); - m_chunk_list.clear(m_chunk_size); -} - -inline void zone::swap(zone& o) -{ - std::swap(*this, o); -} - -template -void zone::object_delete(void* obj) -{ - delete static_cast(obj); -} - -template -void zone::object_destruct(void* obj) -{ - static_cast(obj)->~T(); -} - -inline void zone::undo_allocate(size_t size) -{ - m_chunk_list.m_ptr -= size; - m_chunk_list.m_free += size; -} - - -template -T* zone::allocate(Args... args) -{ - void* x = allocate_align(sizeof(T)); - try { - m_finalizer_array.push(&zone::object_destruct, x); - } catch (...) { - undo_allocate(sizeof(T)); - throw; - } - try { - return new (x) T(args...); - } catch (...) { - --m_finalizer_array.m_tail; - undo_allocate(sizeof(T)); - throw; - } -} - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_CPP11_ZONE_HPP diff --git a/deps/msgpack/msgpack/fbuffer.h b/deps/msgpack/msgpack/fbuffer.h deleted file mode 100644 index d12830e..0000000 --- a/deps/msgpack/msgpack/fbuffer.h +++ /dev/null @@ -1,46 +0,0 @@ -/* - * MessagePack for C FILE* buffer adaptor - * - * Copyright (C) 2013 Vladimir Volodko - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef MSGPACK_FBUFFER_H -#define MSGPACK_FBUFFER_H - -#include - -#ifdef __cplusplus -extern "C" { -#endif - - -/** - * @defgroup msgpack_fbuffer FILE* buffer - * @ingroup msgpack_buffer - * @{ - */ - -static inline int msgpack_fbuffer_write(void* data, const char* buf, unsigned int len) -{ - return (1 == fwrite(buf, len, 1, (FILE *)data)) ? 0 : -1; -} - -/** @} */ - - -#ifdef __cplusplus -} -#endif - -#endif /* msgpack/fbuffer.h */ diff --git a/deps/msgpack/msgpack/fbuffer.hpp b/deps/msgpack/msgpack/fbuffer.hpp deleted file mode 100644 index 8ff0b44..0000000 --- a/deps/msgpack/msgpack/fbuffer.hpp +++ /dev/null @@ -1,68 +0,0 @@ -// -// MessagePack for C++ FILE* buffer adaptor -// -// Copyright (C) 2013 Vladimir Volodko -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_FBUFFER_HPP__ -#define MSGPACK_FBUFFER_HPP__ - -#include "msgpack/versioning.hpp" - -#include -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -class fbuffer { -public: - explicit fbuffer(FILE* file) : m_file(file) { } - -public: - void write(const char* buf, unsigned int len) - { - if (1 != fwrite(buf, len, 1, m_file)) { - throw std::runtime_error("fwrite() failed"); - } - } - - FILE* file() const - { - return m_file; - } - -#if defined(MSGPACK_USE_CPP03) -private: - fbuffer(const fbuffer&); - fbuffer& operator=(const fbuffer&); -#else // defined(MSGPACK_USE_CPP03) - fbuffer(const fbuffer&) = delete; - fbuffer& operator=(const fbuffer&) = delete; -#endif // defined(MSGPACK_USE_CPP03) - -private: - FILE* m_file; -}; - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif /* msgpack/fbuffer.hpp */ diff --git a/deps/msgpack/msgpack/gcc_atomic.h b/deps/msgpack/msgpack/gcc_atomic.h deleted file mode 100644 index 276acdc..0000000 --- a/deps/msgpack/msgpack/gcc_atomic.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef MSGPACK_GCC_ATOMIC_H -#define MSGPACK_GCC_ATOMIC_H - -#if defined(__cplusplus) -extern "C" { -#endif - -typedef int _msgpack_atomic_counter_t; - -int _msgpack_sync_decr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); -int _msgpack_sync_incr_and_fetch(volatile _msgpack_atomic_counter_t* ptr); - - -#if defined(__cplusplus) -} -#endif - - -#endif // MSGPACK_GCC_ATOMIC_H diff --git a/deps/msgpack/msgpack/iterator.hpp b/deps/msgpack/msgpack/iterator.hpp deleted file mode 100644 index f7c7c75..0000000 --- a/deps/msgpack/msgpack/iterator.hpp +++ /dev/null @@ -1,46 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2015 MIZUKI Hirata -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -#ifndef MSGPACK_ITERATOR_HPP -#define MSGPACK_ITERATOR_HPP -#if !defined(MSGPACK_USE_CPP03) - -#include - -namespace msgpack -{ - /// @cond - MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) - { - /// @endcond - inline object_kv* begin(object_map &map) { return map.ptr; } - inline const object_kv* begin(const object_map &map) { return map.ptr; } - inline object_kv* end(object_map &map) { return map.ptr + map.size; } - inline const object_kv* end(const object_map &map) { return map.ptr + map.size; } - - inline object* begin(object_array &array) { return array.ptr; } - inline const object* begin(const object_array &array) { return array.ptr; } - inline object* end(object_array &array) { return array.ptr + array.size; } - inline const object* end(const object_array &array) { return array.ptr + array.size; } - /// @cond - } - /// @endcond -} - -#endif // !defined(MSGPACK_USE_CPP03) -#endif // MSGPACK_ITERATOR_HPP diff --git a/deps/msgpack/msgpack/object.hpp b/deps/msgpack/msgpack/object.hpp deleted file mode 100644 index 2bcccc2..0000000 --- a/deps/msgpack/msgpack/object.hpp +++ /dev/null @@ -1,640 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_OBJECT_HPP -#define MSGPACK_OBJECT_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/pack.hpp" -#include "msgpack/zone.hpp" -#include "msgpack/adaptor/adaptor_base.hpp" - -#include -#include -#include -#include -#include -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -struct object::implicit_type { - implicit_type(object const& o) : obj(o) { } - ~implicit_type() { } - - template - operator T() { return obj.as(); } - -private: - msgpack::object const& obj; -}; - -namespace detail { -template -struct packer_serializer { - static msgpack::packer& pack(msgpack::packer& o, const T& v) { - v.msgpack_pack(o); - return o; - } -}; -} // namespace detail - -// Adaptor functors' member functions definitions. -template -inline -msgpack::object const& -msgpack::adaptor::convert::operator()(msgpack::object const& o, T& v) const { - v.msgpack_unpack(o.convert()); - return o; -} - -template -template -inline -msgpack::packer& -msgpack::adaptor::pack::operator()(msgpack::packer& o, T const& v) const { - return detail::packer_serializer::pack(o, v); -} - -template -inline -void -msgpack::adaptor::object_with_zone::operator()(msgpack::object::with_zone& o, T const& v) const { - v.msgpack_object(static_cast(&o), o.zone); -} - -// Adaptor functor specialization to object -namespace adaptor { - -template <> -struct convert { - msgpack::object const& operator()(msgpack::object const& o, msgpack::object& v) const { - v = o; - return o; - } -}; - -template <> -struct pack { - template - msgpack::packer& operator()(msgpack::packer& o, msgpack::object const& v) const { - switch(v.type) { - case msgpack::type::NIL: - o.pack_nil(); - return o; - - case msgpack::type::BOOLEAN: - if(v.via.boolean) { - o.pack_true(); - } else { - o.pack_false(); - } - return o; - - case msgpack::type::POSITIVE_INTEGER: - o.pack_uint64(v.via.u64); - return o; - - case msgpack::type::NEGATIVE_INTEGER: - o.pack_int64(v.via.i64); - return o; - - case msgpack::type::FLOAT: - o.pack_double(v.via.f64); - return o; - - case msgpack::type::STR: - o.pack_str(v.via.str.size); - o.pack_str_body(v.via.str.ptr, v.via.str.size); - return o; - - case msgpack::type::BIN: - o.pack_bin(v.via.bin.size); - o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); - return o; - - case msgpack::type::EXT: - o.pack_ext(v.via.ext.size, v.via.ext.type()); - o.pack_ext_body(v.via.ext.data(), v.via.ext.size); - return o; - - case msgpack::type::ARRAY: - o.pack_array(v.via.array.size); - for(msgpack::object* p(v.via.array.ptr), - * const pend(v.via.array.ptr + v.via.array.size); - p < pend; ++p) { - msgpack::operator<<(o, *p); - } - return o; - - case msgpack::type::MAP: - o.pack_map(v.via.map.size); - for(msgpack::object_kv* p(v.via.map.ptr), - * const pend(v.via.map.ptr + v.via.map.size); - p < pend; ++p) { - msgpack::operator<<(o, p->key); - msgpack::operator<<(o, p->val); - } - return o; - - default: - throw msgpack::type_error(); - } - } -}; - -template <> -struct object_with_zone { - void operator()(msgpack::object::with_zone& o, msgpack::object const& v) const { - o.type = v.type; - - switch(v.type) { - case msgpack::type::NIL: - case msgpack::type::BOOLEAN: - case msgpack::type::POSITIVE_INTEGER: - case msgpack::type::NEGATIVE_INTEGER: - case msgpack::type::FLOAT: - std::memcpy(&o.via, &v.via, sizeof(v.via)); - return; - - case msgpack::type::STR: { - char* ptr = static_cast(o.zone.allocate_align(v.via.str.size)); - o.via.str.ptr = ptr; - o.via.str.size = v.via.str.size; - std::memcpy(ptr, v.via.str.ptr, v.via.str.size); - return; - } - - case msgpack::type::BIN: { - char* ptr = static_cast(o.zone.allocate_align(v.via.bin.size)); - o.via.bin.ptr = ptr; - o.via.bin.size = v.via.bin.size; - std::memcpy(ptr, v.via.bin.ptr, v.via.bin.size); - return; - } - - case msgpack::type::EXT: { - char* ptr = static_cast(o.zone.allocate_align(v.via.ext.size + 1)); - o.via.ext.ptr = ptr; - o.via.ext.size = v.via.ext.size; - std::memcpy(ptr, v.via.ext.ptr, v.via.ext.size + 1); - return; - } - - case msgpack::type::ARRAY: - o.via.array.ptr = static_cast(o.zone.allocate_align(sizeof(msgpack::object) * v.via.array.size)); - o.via.array.size = v.via.array.size; - for (msgpack::object - * po(o.via.array.ptr), - * pv(v.via.array.ptr), - * const pvend(v.via.array.ptr + v.via.array.size); - pv < pvend; - ++po, ++pv) { - new (po) msgpack::object(*pv, o.zone); - } - return; - - case msgpack::type::MAP: - o.via.map.ptr = (msgpack::object_kv*)o.zone.allocate_align(sizeof(msgpack::object_kv) * v.via.map.size); - o.via.map.size = v.via.map.size; - for(msgpack::object_kv - * po(o.via.map.ptr), - * pv(v.via.map.ptr), - * const pvend(v.via.map.ptr + v.via.map.size); - pv < pvend; - ++po, ++pv) { - msgpack::object_kv* kv = new (po) msgpack::object_kv; - new (&kv->key) msgpack::object(pv->key, o.zone); - new (&kv->val) msgpack::object(pv->val, o.zone); - } - return; - - default: - throw msgpack::type_error(); - } - - } -}; - -// Adaptor functor specialization to object::with_zone - -template <> -struct object_with_zone { - void operator()( - msgpack::object::with_zone& o, - msgpack::object::with_zone const& v) const { - o << static_cast(v); - } -}; - - -} // namespace adaptor - - -// obsolete -template -class define : public Type { -public: - typedef Type msgpack_type; - typedef define define_type; - - define() {} - define(const msgpack_type& v) : msgpack_type(v) {} - - template - void msgpack_pack(Packer& o) const - { - msgpack::operator<<(o, static_cast(*this)); - } - - void msgpack_unpack(object const& o) - { - msgpack::operator>>(o, static_cast(*this)); - } -}; - -// deconvert operator - -template -template -inline msgpack::packer& packer::pack(const T& v) -{ - msgpack::operator<<(*this, v); - return *this; -} - -inline bool operator==(const msgpack::object& x, const msgpack::object& y) -{ - if(x.type != y.type) { return false; } - - switch(x.type) { - case msgpack::type::NIL: - return true; - - case msgpack::type::BOOLEAN: - return x.via.boolean == y.via.boolean; - - case msgpack::type::POSITIVE_INTEGER: - return x.via.u64 == y.via.u64; - - case msgpack::type::NEGATIVE_INTEGER: - return x.via.i64 == y.via.i64; - - case msgpack::type::FLOAT: - return x.via.f64 == y.via.f64; - - case msgpack::type::STR: - return x.via.str.size == y.via.str.size && - std::memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; - - case msgpack::type::BIN: - return x.via.bin.size == y.via.bin.size && - std::memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; - - case msgpack::type::EXT: - return x.via.ext.size == y.via.ext.size && - std::memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; - - case msgpack::type::ARRAY: - if(x.via.array.size != y.via.array.size) { - return false; - } else if(x.via.array.size == 0) { - return true; - } else { - msgpack::object* px = x.via.array.ptr; - msgpack::object* const pxend = x.via.array.ptr + x.via.array.size; - msgpack::object* py = y.via.array.ptr; - do { - if(!(*px == *py)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } - - case msgpack::type::MAP: - if(x.via.map.size != y.via.map.size) { - return false; - } else if(x.via.map.size == 0) { - return true; - } else { - msgpack::object_kv* px = x.via.map.ptr; - msgpack::object_kv* const pxend = x.via.map.ptr + x.via.map.size; - msgpack::object_kv* py = y.via.map.ptr; - do { - if(!(px->key == py->key) || !(px->val == py->val)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } - - default: - return false; - } -} - -template -inline bool operator==(const msgpack::object& x, const T& y) -try { - return x == msgpack::object(y); -} catch (msgpack::type_error&) { - return false; -} - -inline bool operator!=(const msgpack::object& x, const msgpack::object& y) -{ return !(x == y); } - -template -inline bool operator==(const T& y, const msgpack::object x) -{ return x == y; } - -template -inline bool operator!=(const msgpack::object& x, const T& y) -{ return !(x == y); } - -template -inline bool operator!=(const T& y, const msgpack::object& x) -{ return x != y; } - - -inline msgpack::object::implicit_type object::convert() const -{ - return msgpack::object::implicit_type(*this); -} - -template -inline void object::convert(T& v) const -{ - msgpack::operator>>(*this, v); -} - -template -inline void object::convert(T* v) const -{ - convert(*v); -} - -template -inline T object::as() const -{ - T v; - convert(v); - return v; -} - - -inline object::object() -{ - type = msgpack::type::NIL; -} - -template -inline object::object(const T& v) -{ - msgpack::operator<<(*this, v); -} - -template -inline object& object::operator=(const T& v) -{ - *this = object(v); - return *this; -} - -template -object::object(const T& v, msgpack::zone& z) -{ - with_zone oz(z); - msgpack::operator<<(oz, v); - type = oz.type; - via = oz.via; -} - -template -object::object(const T& v, msgpack::zone* z) -{ - with_zone oz(*z); - msgpack::operator<<(oz, v); - type = oz.type; - via = oz.via; -} - - -inline object::object(const msgpack_object& o) -{ - // FIXME beter way? - std::memcpy(this, &o, sizeof(o)); -} - -inline void operator<< (msgpack::object& o, const msgpack_object& v) -{ - // FIXME beter way? - std::memcpy(&o, &v, sizeof(v)); -} - -inline object::operator msgpack_object() const -{ - // FIXME beter way? - msgpack_object obj; - std::memcpy(&obj, this, sizeof(obj)); - return obj; -} - - -// obsolete -template -inline void convert(T& v, msgpack::object const& o) -{ - o.convert(v); -} - -// obsolete -template -inline void pack(msgpack::packer& o, const T& v) -{ - o.pack(v); -} - -// obsolete -template -inline void pack_copy(msgpack::packer& o, T v) -{ - pack(o, v); -} - - -template -inline msgpack::packer& operator<< (msgpack::packer& o, const msgpack::object& v) -{ - switch(v.type) { - case msgpack::type::NIL: - o.pack_nil(); - return o; - - case msgpack::type::BOOLEAN: - if(v.via.boolean) { - o.pack_true(); - } else { - o.pack_false(); - } - return o; - - case msgpack::type::POSITIVE_INTEGER: - o.pack_uint64(v.via.u64); - return o; - - case msgpack::type::NEGATIVE_INTEGER: - o.pack_int64(v.via.i64); - return o; - - case msgpack::type::FLOAT: - o.pack_double(v.via.f64); - return o; - - case msgpack::type::STR: - o.pack_str(v.via.str.size); - o.pack_str_body(v.via.str.ptr, v.via.str.size); - return o; - - case msgpack::type::BIN: - o.pack_bin(v.via.bin.size); - o.pack_bin_body(v.via.bin.ptr, v.via.bin.size); - return o; - - case msgpack::type::EXT: - o.pack_ext(v.via.ext.size, v.via.ext.type()); - o.pack_ext_body(v.via.ext.data(), v.via.ext.size); - return o; - - case msgpack::type::ARRAY: - o.pack_array(v.via.array.size); - for(msgpack::object* p(v.via.array.ptr), - * const pend(v.via.array.ptr + v.via.array.size); - p < pend; ++p) { - msgpack::operator<<(o, *p); - } - return o; - - case msgpack::type::MAP: - o.pack_map(v.via.map.size); - for(msgpack::object_kv* p(v.via.map.ptr), - * const pend(v.via.map.ptr + v.via.map.size); - p < pend; ++p) { - msgpack::operator<<(o, p->key); - msgpack::operator<<(o, p->val); - } - return o; - - default: - throw msgpack::type_error(); - } -} - -template -msgpack::packer& operator<< (msgpack::packer& o, const msgpack::object::with_zone& v) -{ - return o << static_cast(v); -} - -inline std::ostream& operator<< (std::ostream& s, const msgpack::object& o) -{ - switch(o.type) { - case msgpack::type::NIL: - s << "nil"; - break; - - case msgpack::type::BOOLEAN: - s << (o.via.boolean ? "true" : "false"); - break; - - case msgpack::type::POSITIVE_INTEGER: - s << o.via.u64; - break; - - case msgpack::type::NEGATIVE_INTEGER: - s << o.via.i64; - break; - - case msgpack::type::FLOAT: - s << o.via.f64; - break; - - case msgpack::type::STR: - (s << '"').write(o.via.str.ptr, o.via.str.size) << '"'; - break; - - case msgpack::type::BIN: - (s << '"').write(o.via.bin.ptr, o.via.bin.size) << '"'; - break; - - case msgpack::type::EXT: - s << "EXT"; - break; - - case msgpack::type::ARRAY: - s << "["; - if(o.via.array.size != 0) { - msgpack::object* p(o.via.array.ptr); - s << *p; - ++p; - for(msgpack::object* const pend(o.via.array.ptr + o.via.array.size); - p < pend; ++p) { - s << ", " << *p; - } - } - s << "]"; - break; - - case msgpack::type::MAP: - s << "{"; - if(o.via.map.size != 0) { - msgpack::object_kv* p(o.via.map.ptr); - s << p->key << "=>" << p->val; - ++p; - for(msgpack::object_kv* const pend(o.via.map.ptr + o.via.map.size); - p < pend; ++p) { - s << ", " << p->key << "=>" << p->val; - } - } - s << "}"; - break; - - default: - // FIXME - s << "#(o.type) << ">"; - } - return s; -} - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#include "msgpack/type.hpp" - -#endif /* msgpack/object.hpp */ diff --git a/deps/msgpack/msgpack/object_fwd.hpp b/deps/msgpack/msgpack/object_fwd.hpp deleted file mode 100644 index 21483bc..0000000 --- a/deps/msgpack/msgpack/object_fwd.hpp +++ /dev/null @@ -1,161 +0,0 @@ -// -// MessagePack for C++ static resolution routine -// -// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -#ifndef MSGPACK_OBJECT_FWD_HPP -#define MSGPACK_OBJECT_FWD_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/zone.hpp" -#include "msgpack/object.h" - -#include - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - - -namespace type { - enum object_type { - NIL = MSGPACK_OBJECT_NIL, - BOOLEAN = MSGPACK_OBJECT_BOOLEAN, - POSITIVE_INTEGER = MSGPACK_OBJECT_POSITIVE_INTEGER, - NEGATIVE_INTEGER = MSGPACK_OBJECT_NEGATIVE_INTEGER, - FLOAT = MSGPACK_OBJECT_FLOAT, -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - DOUBLE = MSGPACK_OBJECT_DOUBLE, // obsolete -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - STR = MSGPACK_OBJECT_STR, - BIN = MSGPACK_OBJECT_BIN, - ARRAY = MSGPACK_OBJECT_ARRAY, - MAP = MSGPACK_OBJECT_MAP, - EXT = MSGPACK_OBJECT_EXT - }; -} - - -struct object; -struct object_kv; - -struct object_array { - uint32_t size; - msgpack::object* ptr; -}; - -struct object_map { - uint32_t size; - msgpack::object_kv* ptr; -}; - -struct object_str { - uint32_t size; - const char* ptr; -}; - -struct object_bin { - uint32_t size; - const char* ptr; -}; - -struct object_ext { - int8_t type() const { return ptr[0]; } - const char* data() const { return &ptr[1]; } - uint32_t size; - const char* ptr; -}; - -struct object { - union union_type { - bool boolean; - uint64_t u64; - int64_t i64; -#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT) - double dec; // obsolete -#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT - double f64; - msgpack::object_array array; - msgpack::object_map map; - msgpack::object_str str; - msgpack::object_bin bin; - msgpack::object_ext ext; - }; - - msgpack::type::object_type type; - union_type via; - - bool is_nil() const { return type == msgpack::type::NIL; } - - template - T as() const; - - template - void convert(T& v) const; - template - void convert(T* v) const; - - object(); - - object(const msgpack_object& o); - - template - explicit object(const T& v); - - template - object(const T& v, msgpack::zone& z); - - // obsolete - template - object(const T& v, msgpack::zone* z); - - template - object& operator=(const T& v); - - operator msgpack_object() const; - - struct with_zone; - -private: - struct implicit_type; - -public: - implicit_type convert() const; -}; - -class type_error : public std::bad_cast { }; - -struct object_kv { - msgpack::object key; - msgpack::object val; -}; - -struct object::with_zone : object { - with_zone(msgpack::zone& zone) : zone(zone) { } - msgpack::zone& zone; -private: - with_zone(); -}; - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif // MSGPACK_OBJECT_FWD_HPP diff --git a/deps/msgpack/msgpack/pack.hpp b/deps/msgpack/msgpack/pack.hpp deleted file mode 100644 index 3f4c12d..0000000 --- a/deps/msgpack/msgpack/pack.hpp +++ /dev/null @@ -1,1061 +0,0 @@ -// -// MessagePack for C++ serializing routine -// -// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_PACK_HPP -#define MSGPACK_PACK_HPP - -#include "msgpack/versioning.hpp" -#include "msgpack/cpp_config.hpp" - -#include -#include -#include -#include - -#include "sysdep.h" - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -template -class packer { -public: - packer(Stream* s); - packer(Stream& s); - -public: - template - packer& pack(const T& v); - - packer& pack_uint8(uint8_t d); - packer& pack_uint16(uint16_t d); - packer& pack_uint32(uint32_t d); - packer& pack_uint64(uint64_t d); - packer& pack_int8(int8_t d); - packer& pack_int16(int16_t d); - packer& pack_int32(int32_t d); - packer& pack_int64(int64_t d); - - packer& pack_fix_uint8(uint8_t d); - packer& pack_fix_uint16(uint16_t d); - packer& pack_fix_uint32(uint32_t d); - packer& pack_fix_uint64(uint64_t d); - packer& pack_fix_int8(int8_t d); - packer& pack_fix_int16(int16_t d); - packer& pack_fix_int32(int32_t d); - packer& pack_fix_int64(int64_t d); - - packer& pack_char(char d); - packer& pack_signed_char(signed char d); - packer& pack_short(short d); - packer& pack_int(int d); - packer& pack_long(long d); - packer& pack_long_long(long long d); - packer& pack_unsigned_char(unsigned char d); - packer& pack_unsigned_short(unsigned short d); - packer& pack_unsigned_int(unsigned int d); - packer& pack_unsigned_long(unsigned long d); - packer& pack_unsigned_long_long(unsigned long long d); - - packer& pack_float(float d); - packer& pack_double(double d); - - packer& pack_nil(); - packer& pack_true(); - packer& pack_false(); - - packer& pack_array(uint32_t n); - - packer& pack_map(uint32_t n); - - packer& pack_str(uint32_t l); - packer& pack_str_body(const char* b, uint32_t l); - - packer& pack_bin(uint32_t l); - packer& pack_bin_body(const char* b, uint32_t l); - - packer& pack_ext(size_t l, int8_t type); - packer& pack_ext_body(const char* b, uint32_t l); - -private: - template - void pack_imp_uint8(T d); - template - void pack_imp_uint16(T d); - template - void pack_imp_uint32(T d); - template - void pack_imp_uint64(T d); - template - void pack_imp_int8(T d); - template - void pack_imp_int16(T d); - template - void pack_imp_int32(T d); - template - void pack_imp_int64(T d); - - void append_buffer(const char* buf, size_t len) - { m_stream.write(buf, len); } - -private: - Stream& m_stream; - -#if defined(MSGPACK_USE_CPP03) -private: - packer(const packer&); - packer& operator=(const packer&); - packer(); -#else // defined(MSGPACK_USE_CPP03) -public: - packer(const packer&) = delete; - packer& operator=(const packer&) = delete; - packer() = delete; -#endif // defined(MSGPACK_USE_CPP03) -}; - - -template -inline void pack(Stream* s, const T& v) -{ - packer(*s).pack(v); -} - -template -inline void pack(Stream& s, const T& v) -{ - packer(s).pack(v); -} - - -#if defined(__LITTLE_ENDIAN__) -template -inline char take8_8(T d) { - return static_cast(reinterpret_cast(&d)[0]); -} -template -inline char take8_16(T d) { - return static_cast(reinterpret_cast(&d)[0]); -} -template -inline char take8_32(T d) { - return static_cast(reinterpret_cast(&d)[0]); -} -template -inline char take8_64(T d) { - return static_cast(reinterpret_cast(&d)[0]); -} - -#elif defined(__BIG_ENDIAN__) - -template -inline char take8_8(T d) { - return static_cast(reinterpret_cast(&d)[0]); -} -template -inline char take8_16(T d) { - return static_cast(reinterpret_cast(&d)[1]); -} -template -inline char take8_32(T d) { - return static_cast(reinterpret_cast(&d)[3]); -} -template -inline char take8_64(T d) { - return static_cast(reinterpret_cast(&d)[7]); -} - -#endif - -template -inline packer::packer(Stream* s) : m_stream(*s) { } - -template -inline packer::packer(Stream& s) : m_stream(s) { } - - -template -inline packer& packer::pack_uint8(uint8_t d) -{ pack_imp_uint8(d); return *this; } - -template -inline packer& packer::pack_uint16(uint16_t d) -{ pack_imp_uint16(d); return *this; } - -template -inline packer& packer::pack_uint32(uint32_t d) -{ pack_imp_uint32(d); return *this; } - -template -inline packer& packer::pack_uint64(uint64_t d) -{ pack_imp_uint64(d); return *this; } - -template -inline packer& packer::pack_int8(int8_t d) -{ pack_imp_int8(d); return *this; } - -template -inline packer& packer::pack_int16(int16_t d) -{ pack_imp_int16(d); return *this; } - -template -inline packer& packer::pack_int32(int32_t d) -{ pack_imp_int32(d); return *this; } - -template -inline packer& packer::pack_int64(int64_t d) -{ pack_imp_int64(d); return *this;} - - -template -inline packer& packer::pack_fix_uint8(uint8_t d) -{ - char buf[2] = {static_cast(0xccu), take8_8(d)}; - append_buffer(buf, 2); - return *this; -} - -template -inline packer& packer::pack_fix_uint16(uint16_t d) -{ - char buf[3]; - buf[0] = static_cast(0xcdu); _msgpack_store16(&buf[1], d); - append_buffer(buf, 3); - return *this; -} - -template -inline packer& packer::pack_fix_uint32(uint32_t d) -{ - char buf[5]; - buf[0] = static_cast(0xceu); _msgpack_store32(&buf[1], d); - append_buffer(buf, 5); - return *this; -} - -template -inline packer& packer::pack_fix_uint64(uint64_t d) -{ - char buf[9]; - buf[0] = static_cast(0xcfu); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - return *this; -} - -template -inline packer& packer::pack_fix_int8(int8_t d) -{ - char buf[2] = {static_cast(0xd0u), take8_8(d)}; - append_buffer(buf, 2); - return *this; -} - -template -inline packer& packer::pack_fix_int16(int16_t d) -{ - char buf[3]; - buf[0] = static_cast(0xd1u); _msgpack_store16(&buf[1], d); - append_buffer(buf, 3); - return *this; -} - -template -inline packer& packer::pack_fix_int32(int32_t d) -{ - char buf[5]; - buf[0] = static_cast(0xd2u); _msgpack_store32(&buf[1], d); - append_buffer(buf, 5); - return *this; -} - -template -inline packer& packer::pack_fix_int64(int64_t d) -{ - char buf[9]; - buf[0] = static_cast(0xd3u); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - return *this; -} - - -template -inline packer& packer::pack_char(char d) -{ -#if defined(CHAR_MIN) -#if CHAR_MIN < 0 - pack_imp_int8(d); -#else - pack_imp_uint8(d); -#endif -#else -#error CHAR_MIN is not defined -#endif - return *this; -} - -template -inline packer& packer::pack_signed_char(signed char d) -{ - pack_imp_int8(d); - return *this; -} - -template -inline packer& packer::pack_short(short d) -{ -#if defined(SIZEOF_SHORT) -#if SIZEOF_SHORT == 2 - pack_imp_int16(d); -#elif SIZEOF_SHORT == 4 - pack_imp_int32(d); -#else - pack_imp_int64(d); -#endif - -#elif defined(SHRT_MAX) -#if SHRT_MAX == 0x7fff - pack_imp_int16(d); -#elif SHRT_MAX == 0x7fffffff - pack_imp_int32(d); -#else - pack_imp_int64(d); -#endif - -#else - if(sizeof(short) == 2) { - pack_imp_int16(d); - } else if(sizeof(short) == 4) { - pack_imp_int32(d); - } else { - pack_imp_int64(d); - } -#endif - return *this; -} - -template -inline packer& packer::pack_int(int d) -{ -#if defined(SIZEOF_INT) -#if SIZEOF_INT == 2 - pack_imp_int16(d); -#elif SIZEOF_INT == 4 - pack_imp_int32(d); -#else - pack_imp_int64(d); -#endif - -#elif defined(INT_MAX) -#if INT_MAX == 0x7fff - pack_imp_int16(d); -#elif INT_MAX == 0x7fffffff - pack_imp_int32(d); -#else - pack_imp_int64(d); -#endif - -#else - if(sizeof(int) == 2) { - pack_imp_int16(d); - } else if(sizeof(int) == 4) { - pack_imp_int32(d); - } else { - pack_imp_int64(d); - } -#endif - return *this; -} - -template -inline packer& packer::pack_long(long d) -{ -#if defined(SIZEOF_LONG) -#if SIZEOF_LONG == 2 - pack_imp_int16(d); -#elif SIZEOF_LONG == 4 - pack_imp_int32(d); -#else - pack_imp_int64(d); -#endif - -#elif defined(LONG_MAX) -#if LONG_MAX == 0x7fffL - pack_imp_int16(d); -#elif LONG_MAX == 0x7fffffffL - pack_imp_int32(d); -#else - pack_imp_int64(d); -#endif - -#else - if(sizeof(long) == 2) { - pack_imp_int16(d); - } else if(sizeof(long) == 4) { - pack_imp_int32(d); - } else { - pack_imp_int64(d); - } -#endif - return *this; -} - -template -inline packer& packer::pack_long_long(long long d) -{ -#if defined(SIZEOF_LONG_LONG) -#if SIZEOF_LONG_LONG == 2 - pack_imp_int16(d); -#elif SIZEOF_LONG_LONG == 4 - pack_imp_int32(d); -#else - pack_imp_int64(d); -#endif - -#elif defined(LLONG_MAX) -#if LLONG_MAX == 0x7fffL - pack_imp_int16(d); -#elif LLONG_MAX == 0x7fffffffL - pack_imp_int32(d); -#else - pack_imp_int64(d); -#endif - -#else - if(sizeof(long long) == 2) { - pack_imp_int16(d); - } else if(sizeof(long long) == 4) { - pack_imp_int32(d); - } else { - pack_imp_int64(d); - } -#endif - return *this; -} - - -template -inline packer& packer::pack_unsigned_char(unsigned char d) -{ - pack_imp_uint8(d); - return *this; -} - -template -inline packer& packer::pack_unsigned_short(unsigned short d) -{ -#if defined(SIZEOF_SHORT) -#if SIZEOF_SHORT == 2 - pack_imp_uint16(d); -#elif SIZEOF_SHORT == 4 - pack_imp_uint32(d); -#else - pack_imp_uint64(d); -#endif - -#elif defined(USHRT_MAX) -#if USHRT_MAX == 0xffffU - pack_imp_uint16(d); -#elif USHRT_MAX == 0xffffffffU - pack_imp_uint32(d); -#else - pack_imp_uint64(d); -#endif - -#else - if(sizeof(unsigned short) == 2) { - pack_imp_uint16(d); - } else if(sizeof(unsigned short) == 4) { - pack_imp_uint32(d); - } else { - pack_imp_uint64(d); - } -#endif - return *this; -} - -template -inline packer& packer::pack_unsigned_int(unsigned int d) -{ -#if defined(SIZEOF_INT) -#if SIZEOF_INT == 2 - pack_imp_uint16(d); -#elif SIZEOF_INT == 4 - pack_imp_uint32(d); -#else - pack_imp_uint64(d); -#endif - -#elif defined(UINT_MAX) -#if UINT_MAX == 0xffffU - pack_imp_uint16(d); -#elif UINT_MAX == 0xffffffffU - pack_imp_uint32(d); -#else - pack_imp_uint64(d); -#endif - -#else - if(sizeof(unsigned int) == 2) { - pack_imp_uint16(d); - } else if(sizeof(unsigned int) == 4) { - pack_imp_uint32(d); - } else { - pack_imp_uint64(d); - } -#endif - return *this; -} - -template -inline packer& packer::pack_unsigned_long(unsigned long d) -{ -#if defined(SIZEOF_LONG) -#if SIZEOF_LONG == 2 - pack_imp_uint16(d); -#elif SIZEOF_LONG == 4 - pack_imp_uint32(d); -#else - pack_imp_uint64(d); -#endif - -#elif defined(ULONG_MAX) -#if ULONG_MAX == 0xffffUL - pack_imp_uint16(d); -#elif ULONG_MAX == 0xffffffffUL - pack_imp_uint32(d); -#else - pack_imp_uint64(d); -#endif - -#else - if(sizeof(unsigned long) == 2) { - pack_imp_uint16(d); - } else if(sizeof(unsigned long) == 4) { - pack_imp_uint32(d); - } else { - pack_imp_uint64(d); - } -#endif - return *this; -} - -template -inline packer& packer::pack_unsigned_long_long(unsigned long long d) -{ -#if defined(SIZEOF_LONG_LONG) -#if SIZEOF_LONG_LONG == 2 - pack_imp_uint16(d); -#elif SIZEOF_LONG_LONG == 4 - pack_imp_uint32(d); -#else - pack_imp_uint64(d); -#endif - -#elif defined(ULLONG_MAX) -#if ULLONG_MAX == 0xffffUL - pack_imp_uint16(d); -#elif ULLONG_MAX == 0xffffffffUL - pack_imp_uint32(d); -#else - pack_imp_uint64(d); -#endif - -#else - if(sizeof(unsigned long long) == 2) { - pack_imp_uint16(d); - } else if(sizeof(unsigned long long) == 4) { - pack_imp_uint32(d); - } else { - pack_imp_uint64(d); - } -#endif - return *this; -} - - -template -inline packer& packer::pack_float(float d) -{ - union { float f; uint32_t i; } mem; - mem.f = d; - char buf[5]; - buf[0] = static_cast(0xcau); _msgpack_store32(&buf[1], mem.i); - append_buffer(buf, 5); - return *this; -} - -template -inline packer& packer::pack_double(double d) -{ - union { double f; uint64_t i; } mem; - mem.f = d; - char buf[9]; - buf[0] = static_cast(0xcbu); -#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); -#endif - _msgpack_store64(&buf[1], mem.i); - append_buffer(buf, 9); - return *this; -} - - -template -inline packer& packer::pack_nil() -{ - const char d = static_cast(0xc0u); - append_buffer(&d, 1); - return *this; -} - -template -inline packer& packer::pack_true() -{ - const char d = static_cast(0xc3u); - append_buffer(&d, 1); - return *this; -} - -template -inline packer& packer::pack_false() -{ - const char d = static_cast(0xc2u); - append_buffer(&d, 1); - return *this; -} - - -template -inline packer& packer::pack_array(uint32_t n) -{ - if(n < 16) { - char d = static_cast(0x90u | n); - append_buffer(&d, 1); - } else if(n < 65536) { - char buf[3]; - buf[0] = static_cast(0xdcu); _msgpack_store16(&buf[1], static_cast(n)); - append_buffer(buf, 3); - } else { - char buf[5]; - buf[0] = static_cast(0xddu); _msgpack_store32(&buf[1], static_cast(n)); - append_buffer(buf, 5); - } - return *this; -} - -template -inline packer& packer::pack_map(uint32_t n) -{ - if(n < 16) { - unsigned char d = static_cast(0x80u | n); - char buf = take8_8(d); - append_buffer(&buf, 1); - } else if(n < 65536) { - char buf[3]; - buf[0] = static_cast(0xdeu); _msgpack_store16(&buf[1], static_cast(n)); - append_buffer(buf, 3); - } else { - char buf[5]; - buf[0] = static_cast(0xdfu); _msgpack_store32(&buf[1], static_cast(n)); - append_buffer(buf, 5); - } - return *this; -} - -template -inline packer& packer::pack_str(uint32_t l) -{ - if(l < 32) { - unsigned char d = 0xa0u | static_cast(l); - char buf = take8_8(d); - append_buffer(&buf, 1); - } else if(l < 256) { - char buf[2]; - buf[0] = static_cast(0xd9u); buf[1] = static_cast(l); - append_buffer(buf, 2); - } else if(l < 65536) { - char buf[3]; - buf[0] = static_cast(0xdau); _msgpack_store16(&buf[1], static_cast(l)); - append_buffer(buf, 3); - } else { - char buf[5]; - buf[0] = static_cast(0xdbu); _msgpack_store32(&buf[1], static_cast(l)); - append_buffer(buf, 5); - } - return *this; -} - -template -inline packer& packer::pack_str_body(const char* b, uint32_t l) -{ - append_buffer(b, l); - return *this; -} - -template -inline packer& packer::pack_bin(uint32_t l) -{ - if(l < 256) { - char buf[2]; - buf[0] = static_cast(0xc4u); buf[1] = static_cast(l); - append_buffer(buf, 2); - } else if(l < 65536) { - char buf[3]; - buf[0] = static_cast(0xc5u); _msgpack_store16(&buf[1], static_cast(l)); - append_buffer(buf, 3); - } else { - char buf[5]; - buf[0] = static_cast(0xc6u); _msgpack_store32(&buf[1], static_cast(l)); - append_buffer(buf, 5); - } - return *this; -} - -template -inline packer& packer::pack_bin_body(const char* b, uint32_t l) -{ - append_buffer(b, l); - return *this; -} - -template -inline packer& packer::pack_ext(size_t l, int8_t type) -{ - switch(l) { - case 1: { - char buf[2]; - buf[0] = static_cast(0xd4u); - buf[1] = static_cast(type); - append_buffer(buf, 2); - } break; - case 2: { - char buf[2]; - buf[0] = static_cast(0xd5u); - buf[1] = static_cast(type); - append_buffer(buf, 2); - } break; - case 4: { - char buf[2]; - buf[0] = static_cast(0xd6u); - buf[1] = static_cast(type); - append_buffer(buf, 2); - } break; - case 8: { - char buf[2]; - buf[0] = static_cast(0xd7u); - buf[1] = static_cast(type); - append_buffer(buf, 2); - } break; - case 16: { - char buf[2]; - buf[0] = static_cast(0xd8u); - buf[1] = static_cast(type); - append_buffer(buf, 2); - } break; - default: - if(l < 256) { - char buf[3]; - buf[0] = static_cast(0xc7u); - buf[1] = static_cast(l); - buf[2] = static_cast(type); - append_buffer(buf, 3); - } else if(l < 65536) { - char buf[4]; - buf[0] = static_cast(0xc8u); - _msgpack_store16(&buf[1], static_cast(l)); - buf[3] = static_cast(type); - append_buffer(buf, 4); - } else { - char buf[6]; - buf[0] = static_cast(0xc9u); - _msgpack_store32(&buf[1], static_cast(l)); - buf[5] = static_cast(type); - append_buffer(buf, 6); - } - break; - } - return *this; -} - -template -inline packer& packer::pack_ext_body(const char* b, uint32_t l) -{ - append_buffer(b, l); - return *this; -} - -template -template -inline void packer::pack_imp_uint8(T d) -{ - if(d < (1<<7)) { - /* fixnum */ - char buf = take8_8(d); - append_buffer(&buf, 1); - } else { - /* unsigned 8 */ - char buf[2] = {static_cast(0xccu), take8_8(d)}; - append_buffer(buf, 2); - } -} - -template -template -inline void packer::pack_imp_uint16(T d) -{ - if(d < (1<<7)) { - /* fixnum */ - char buf = take8_16(d); - append_buffer(&buf, 1); - } else if(d < (1<<8)) { - /* unsigned 8 */ - char buf[2] = {static_cast(0xccu), take8_16(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcdu); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } -} - -template -template -inline void packer::pack_imp_uint32(T d) -{ - if(d < (1<<8)) { - if(d < (1<<7)) { - /* fixnum */ - char buf = take8_32(d); - append_buffer(&buf, 1); - } else { - /* unsigned 8 */ - char buf[2] = {static_cast(0xccu), take8_32(d)}; - append_buffer(buf, 2); - } - } else { - if(d < (1<<16)) { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcdu); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* unsigned 32 */ - char buf[5]; - buf[0] = static_cast(0xceu); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } - } -} - -template -template -inline void packer::pack_imp_uint64(T d) -{ - if(d < (1ULL<<8)) { - if(d < (1ULL<<7)) { - /* fixnum */ - char buf = take8_64(d); - append_buffer(&buf, 1); - } else { - /* unsigned 8 */ - char buf[2] = {static_cast(0xccu), take8_64(d)}; - append_buffer(buf, 2); - } - } else { - if(d < (1ULL<<16)) { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcdu); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else if(d < (1ULL<<32)) { - /* unsigned 32 */ - char buf[5]; - buf[0] = static_cast(0xceu); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } else { - /* unsigned 64 */ - char buf[9]; - buf[0] = static_cast(0xcfu); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } - } -} - -template -template -inline void packer::pack_imp_int8(T d) -{ - if(d < -(1<<5)) { - /* signed 8 */ - char buf[2] = {static_cast(0xd0u), take8_8(d)}; - append_buffer(buf, 2); - } else { - /* fixnum */ - char buf = take8_8(d); - append_buffer(&buf, 1); - } -} - -template -template -inline void packer::pack_imp_int16(T d) -{ - if(d < -(1<<5)) { - if(d < -(1<<7)) { - /* signed 16 */ - char buf[3]; - buf[0] = static_cast(0xd1u); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* signed 8 */ - char buf[2] = {static_cast(0xd0u), take8_16(d)}; - append_buffer(buf, 2); - } - } else if(d < (1<<7)) { - /* fixnum */ - char buf = take8_16(d); - append_buffer(&buf, 1); - } else { - if(d < (1<<8)) { - /* unsigned 8 */ - char buf[2] = {static_cast(0xccu), take8_16(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcdu); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } - } -} - -template -template -inline void packer::pack_imp_int32(T d) -{ - if(d < -(1<<5)) { - if(d < -(1<<15)) { - /* signed 32 */ - char buf[5]; - buf[0] = static_cast(0xd2u); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } else if(d < -(1<<7)) { - /* signed 16 */ - char buf[3]; - buf[0] = static_cast(0xd1u); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* signed 8 */ - char buf[2] = { static_cast(0xd0u), take8_32(d)}; - append_buffer(buf, 2); - } - } else if(d < (1<<7)) { - /* fixnum */ - char buf = take8_32(d); - append_buffer(&buf, 1); - } else { - if(d < (1<<8)) { - /* unsigned 8 */ - char buf[2] = { static_cast(0xccu), take8_32(d)}; - append_buffer(buf, 2); - } else if(d < (1<<16)) { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcdu); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* unsigned 32 */ - char buf[5]; - buf[0] = static_cast(0xceu); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } - } -} - -template -template -inline void packer::pack_imp_int64(T d) -{ - if(d < -(1LL<<5)) { - if(d < -(1LL<<15)) { - if(d < -(1LL<<31)) { - /* signed 64 */ - char buf[9]; - buf[0] = static_cast(0xd3u); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } else { - /* signed 32 */ - char buf[5]; - buf[0] = static_cast(0xd2u); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } - } else { - if(d < -(1<<7)) { - /* signed 16 */ - char buf[3]; - buf[0] = static_cast(0xd1u); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } else { - /* signed 8 */ - char buf[2] = {static_cast(0xd0u), take8_64(d)}; - append_buffer(buf, 2); - } - } - } else if(d < (1<<7)) { - /* fixnum */ - char buf = take8_64(d); - append_buffer(&buf, 1); - } else { - if(d < (1LL<<16)) { - if(d < (1<<8)) { - /* unsigned 8 */ - char buf[2] = {static_cast(0xccu), take8_64(d)}; - append_buffer(buf, 2); - } else { - /* unsigned 16 */ - char buf[3]; - buf[0] = static_cast(0xcdu); _msgpack_store16(&buf[1], static_cast(d)); - append_buffer(buf, 3); - } - } else { - if(d < (1LL<<32)) { - /* unsigned 32 */ - char buf[5]; - buf[0] = static_cast(0xceu); _msgpack_store32(&buf[1], static_cast(d)); - append_buffer(buf, 5); - } else { - /* unsigned 64 */ - char buf[9]; - buf[0] = static_cast(0xcfu); _msgpack_store64(&buf[1], d); - append_buffer(buf, 9); - } - } - } -} - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif /* msgpack/pack.hpp */ diff --git a/deps/msgpack/msgpack/pack_define.h b/deps/msgpack/msgpack/pack_define.h deleted file mode 100644 index 991ee5c..0000000 --- a/deps/msgpack/msgpack/pack_define.h +++ /dev/null @@ -1,26 +0,0 @@ -/* - * MessagePack unpacking routine template - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef MSGPACK_PACK_DEFINE_H -#define MSGPACK_PACK_DEFINE_H - -#include "msgpack/sysdep.h" -#include -#include - -#endif /* msgpack/pack_define.h */ - diff --git a/deps/msgpack/msgpack/sbuffer.hpp b/deps/msgpack/msgpack/sbuffer.hpp deleted file mode 100644 index 2db671a..0000000 --- a/deps/msgpack/msgpack/sbuffer.hpp +++ /dev/null @@ -1,138 +0,0 @@ -// -// MessagePack for C++ simple buffer implementation -// -// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_SBUFFER_HPP -#define MSGPACK_SBUFFER_HPP - -#include "msgpack/versioning.hpp" - -#include - -#ifndef MSGPACK_SBUFFER_INIT_SIZE -#define MSGPACK_SBUFFER_INIT_SIZE 8192 -#endif - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -class sbuffer { -public: - sbuffer(size_t initsz = MSGPACK_SBUFFER_INIT_SIZE):m_size(0), m_alloc(initsz) - { - if(initsz == 0) { - m_data = nullptr; - } else { - m_data = (char*)::malloc(initsz); - if(!m_data) { - throw std::bad_alloc(); - } - } - } - - ~sbuffer() - { - ::free(m_data); - } - -public: - void write(const char* buf, size_t len) - { - if(m_alloc - m_size < len) { - expand_buffer(len); - } - std::memcpy(m_data + m_size, buf, len); - m_size += len; - } - - char* data() - { - return m_data; - } - - const char* data() const - { - return m_data; - } - - size_t size() const - { - return m_size; - } - - char* release() - { - char* tmp = m_data; - m_size = 0; - m_data = nullptr; - m_alloc = 0; - return tmp; - } - - void clear() - { - m_size = 0; - } - -private: - void expand_buffer(size_t len) - { - size_t nsize = (m_alloc > 0) ? - m_alloc * 2 : MSGPACK_SBUFFER_INIT_SIZE; - - while(nsize < m_size + len) { - size_t tmp_nsize = nsize * 2; - if (tmp_nsize <= nsize) { - nsize = m_size + len; - break; - } - nsize = tmp_nsize; - } - - void* tmp = ::realloc(m_data, nsize); - if(!tmp) { - throw std::bad_alloc(); - } - - m_data = static_cast(tmp); - m_alloc = nsize; - } - -#if defined(MSGPACK_USE_CPP03) -private: - sbuffer(const sbuffer&); - sbuffer& operator=(const sbuffer&); -#else // defined(MSGPACK_USE_CPP03) - sbuffer(const sbuffer&) = delete; - sbuffer& operator=(const sbuffer&) = delete; -#endif // defined(MSGPACK_USE_CPP03) - -private: - size_t m_size; - char* m_data; - size_t m_alloc; -}; - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif /* msgpack/sbuffer.hpp */ diff --git a/deps/msgpack/msgpack/sysdep.h b/deps/msgpack/msgpack/sysdep.h deleted file mode 100644 index 80a9997..0000000 --- a/deps/msgpack/msgpack/sysdep.h +++ /dev/null @@ -1,203 +0,0 @@ -/* - * MessagePack system dependencies - * - * Copyright (C) 2008-2010 FURUHASHI Sadayuki - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef MSGPACK_SYSDEP_H -#define MSGPACK_SYSDEP_H - -#include -#include -#if defined(_MSC_VER) && _MSC_VER < 1600 -typedef __int8 int8_t; -typedef unsigned __int8 uint8_t; -typedef __int16 int16_t; -typedef unsigned __int16 uint16_t; -typedef __int32 int32_t; -typedef unsigned __int32 uint32_t; -typedef __int64 int64_t; -typedef unsigned __int64 uint64_t; -#elif defined(_MSC_VER) // && _MSC_VER >= 1600 -#include -#else -#include -#include -#endif - -#if defined(_MSC_VER) -#define MSGPACK_DLLEXPORT __declspec(dllexport) -#else /* _MSC_VER */ -#define MSGPACK_DLLEXPORT -#endif /* _MSC_VER */ - -#ifdef _WIN32 -#define _msgpack_atomic_counter_header -typedef long _msgpack_atomic_counter_t; -#define _msgpack_sync_decr_and_fetch(ptr) InterlockedDecrement(ptr) -#define _msgpack_sync_incr_and_fetch(ptr) InterlockedIncrement(ptr) -#elif defined(__GNUC__) && ((__GNUC__*10 + __GNUC_MINOR__) < 41) - -#if defined(__cplusplus) -#define _msgpack_atomic_counter_header "gcc_atomic.hpp" -#else -#define _msgpack_atomic_counter_header "gcc_atomic.h" -#endif - -#else -typedef unsigned int _msgpack_atomic_counter_t; -#define _msgpack_sync_decr_and_fetch(ptr) __sync_sub_and_fetch(ptr, 1) -#define _msgpack_sync_incr_and_fetch(ptr) __sync_add_and_fetch(ptr, 1) -#endif - -#ifdef _WIN32 - -#ifdef __cplusplus -/* numeric_limits::min,max */ -#ifdef max -#undef max -#endif -#ifdef min -#undef min -#endif -#endif - -#else - -#include /* __BYTE_ORDER */ -# if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__OpenBSD__) && \ - !(defined(__sun) && defined(__SVR4)) -# include -# endif - -#endif - -#if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__) -#if __BYTE_ORDER == __LITTLE_ENDIAN -#define __LITTLE_ENDIAN__ -#elif __BYTE_ORDER == __BIG_ENDIAN -#define __BIG_ENDIAN__ -#elif _WIN32 -#define __LITTLE_ENDIAN__ -#endif -#endif - - -#ifdef __LITTLE_ENDIAN__ - -#ifdef _WIN32 -# if defined(ntohs) -# define _msgpack_be16(x) ntohs(x) -# elif defined(_byteswap_ushort) || (defined(_MSC_VER) && _MSC_VER >= 1400) -# define _msgpack_be16(x) ((uint16_t)_byteswap_ushort((unsigned short)x)) -# else -# define _msgpack_be16(x) ( \ - ((((uint16_t)x) << 8) ) | \ - ((((uint16_t)x) >> 8) ) ) -# endif -#else -# define _msgpack_be16(x) ntohs(x) -#endif - -#ifdef _WIN32 -# if defined(ntohl) -# define _msgpack_be32(x) ntohl(x) -# elif defined(_byteswap_ulong) || (defined(_MSC_VER) && _MSC_VER >= 1400) -# define _msgpack_be32(x) ((uint32_t)_byteswap_ulong((unsigned long)x)) -# else -# define _msgpack_be32(x) \ - ( ((((uint32_t)x) << 24) ) | \ - ((((uint32_t)x) << 8) & 0x00ff0000U ) | \ - ((((uint32_t)x) >> 8) & 0x0000ff00U ) | \ - ((((uint32_t)x) >> 24) ) ) -# endif -#else -# define _msgpack_be32(x) ntohl(x) -#endif - -#if defined(_byteswap_uint64) || (defined(_MSC_VER) && _MSC_VER >= 1400) -# define _msgpack_be64(x) (_byteswap_uint64(x)) -#elif defined(bswap_64) -# define _msgpack_be64(x) bswap_64(x) -#elif defined(__DARWIN_OSSwapInt64) -# define _msgpack_be64(x) __DARWIN_OSSwapInt64(x) -#else -#define _msgpack_be64(x) \ - ( ((((uint64_t)x) << 56) ) | \ - ((((uint64_t)x) << 40) & 0x00ff000000000000ULL ) | \ - ((((uint64_t)x) << 24) & 0x0000ff0000000000ULL ) | \ - ((((uint64_t)x) << 8) & 0x000000ff00000000ULL ) | \ - ((((uint64_t)x) >> 8) & 0x00000000ff000000ULL ) | \ - ((((uint64_t)x) >> 24) & 0x0000000000ff0000ULL ) | \ - ((((uint64_t)x) >> 40) & 0x000000000000ff00ULL ) | \ - ((((uint64_t)x) >> 56) ) ) -#endif - -#else /* __LITTLE_ENDIAN__ */ - -#define _msgpack_be16(x) (x) -#define _msgpack_be32(x) (x) -#define _msgpack_be64(x) (x) - -#endif - -#define _msgpack_load16(cast, from, to) do { \ - memcpy((cast*)(to), (from), sizeof(cast)); \ - *(to) = _msgpack_be16(*(to)); \ - } while (0); - -#define _msgpack_load32(cast, from, to) do { \ - memcpy((cast*)(to), (from), sizeof(cast)); \ - *(to) = _msgpack_be32(*(to)); \ - } while (0); -#define _msgpack_load64(cast, from, to) do { \ - memcpy((cast*)(to), (from), sizeof(cast)); \ - *(to) = _msgpack_be64(*(to)); \ - } while (0); - -#define _msgpack_store16(to, num) \ - do { uint16_t val = _msgpack_be16(num); memcpy(to, &val, 2); } while(0) -#define _msgpack_store32(to, num) \ - do { uint32_t val = _msgpack_be32(num); memcpy(to, &val, 4); } while(0) -#define _msgpack_store64(to, num) \ - do { uint64_t val = _msgpack_be64(num); memcpy(to, &val, 8); } while(0) - -/* -#define _msgpack_load16(cast, from) \ - ({ cast val; memcpy(&val, (char*)from, 2); _msgpack_be16(val); }) -#define _msgpack_load32(cast, from) \ - ({ cast val; memcpy(&val, (char*)from, 4); _msgpack_be32(val); }) -#define _msgpack_load64(cast, from) \ - ({ cast val; memcpy(&val, (char*)from, 8); _msgpack_be64(val); }) -*/ - - -#if !defined(__cplusplus) && defined(_MSC_VER) -# if !defined(FALSE) -# define FALSE (0) -# endif -# if !defined(TRUE) -# define TRUE (!FALSE) -# endif -# if _MSC_VER >= 1800 -# include -# else -# define bool int -# define true TRUE -# define false FALSE -# endif -# define inline __inline -#endif - -#endif /* msgpack/sysdep.h */ diff --git a/deps/msgpack/msgpack/type.hpp b/deps/msgpack/msgpack/type.hpp deleted file mode 100644 index 73f5f6c..0000000 --- a/deps/msgpack/msgpack/type.hpp +++ /dev/null @@ -1,35 +0,0 @@ -#include "cpp_config.hpp" -#include "adaptor/bool.hpp" -#include "adaptor/char_ptr.hpp" -#include "adaptor/deque.hpp" -#include "adaptor/fixint.hpp" -#include "adaptor/float.hpp" -#include "adaptor/int.hpp" -#include "adaptor/list.hpp" -#include "adaptor/map.hpp" -#include "adaptor/nil.hpp" -#include "adaptor/pair.hpp" -#include "adaptor/raw.hpp" -#include "adaptor/set.hpp" -#include "adaptor/string.hpp" -#include "adaptor/vector.hpp" -#include "adaptor/vector_bool.hpp" -#include "adaptor/vector_char.hpp" -#include "adaptor/msgpack_tuple.hpp" -#include "adaptor/define.hpp" - -#if defined(MSGPACK_USE_CPP03) - -#include "adaptor/tr1/unordered_map.hpp" -#include "adaptor/tr1/unordered_set.hpp" - -#else // defined(MSGPACK_USE_CPP03) - -#include "adaptor/cpp11/array.hpp" -#include "adaptor/cpp11/array_char.hpp" -#include "adaptor/cpp11/forward_list.hpp" -#include "adaptor/cpp11/tuple.hpp" -#include "adaptor/cpp11/unordered_map.hpp" -#include "adaptor/cpp11/unordered_set.hpp" - -#endif // defined(MSGPACK_USE_CPP03) diff --git a/deps/msgpack/msgpack/unpack.hpp b/deps/msgpack/msgpack/unpack.hpp deleted file mode 100644 index af55f28..0000000 --- a/deps/msgpack/msgpack/unpack.hpp +++ /dev/null @@ -1,1739 +0,0 @@ -// -// MessagePack for C++ deserializing routine -// -// Copyright (C) 2008-2015 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_UNPACK_HPP -#define MSGPACK_UNPACK_HPP - -#include "msgpack/versioning.hpp" -#include "object.hpp" -#include "zone.hpp" -#include "unpack_define.h" -#include "cpp_config.hpp" -#include "sysdep.h" - -#include -#include - -#if !defined(MSGPACK_USE_CPP03) -#include -#endif - - -#if defined(_MSC_VER) -// avoiding confliction std::max, std::min, and macro in windows.h -#ifndef NOMINMAX -#define NOMINMAX -#endif -#endif // defined(_MSC_VER) - -#ifdef _msgpack_atomic_counter_header -#include _msgpack_atomic_counter_header -#endif - - -const size_t COUNTER_SIZE = sizeof(_msgpack_atomic_counter_t); - -#ifndef MSGPACK_UNPACKER_INIT_BUFFER_SIZE -#define MSGPACK_UNPACKER_INIT_BUFFER_SIZE (64*1024) -#endif - -#ifndef MSGPACK_UNPACKER_RESERVE_SIZE -#define MSGPACK_UNPACKER_RESERVE_SIZE (32*1024) -#endif - - -// backward compatibility -#ifndef MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE -#define MSGPACK_UNPACKER_DEFAULT_INITIAL_BUFFER_SIZE MSGPACK_UNPACKER_INIT_BUFFER_SIZE -#endif - - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -typedef bool (*unpack_reference_func)(msgpack::type::object_type, std::size_t, void*); - -struct unpack_error : public std::runtime_error { - explicit unpack_error(const std::string& msg) - :std::runtime_error(msg) {} -#if !defined(MSGPACK_USE_CPP03) - explicit unpack_error(const char* msg): - std::runtime_error(msg) {} -#endif // !defined(MSGPACK_USE_CPP03) -}; - -struct parse_error : public unpack_error { - explicit parse_error(const std::string& msg) - :unpack_error(msg) {} -#if !defined(MSGPACK_USE_CPP03) - explicit parse_error(const char* msg) - :unpack_error(msg) {} -#endif // !defined(MSGPACK_USE_CPP03) -}; - -struct insufficient_bytes : public unpack_error { - explicit insufficient_bytes(const std::string& msg) - :unpack_error(msg) {} -#if !defined(MSGPACK_USE_CPP03) - explicit insufficient_bytes(const char* msg) - :unpack_error(msg) {} -#endif // !defined(MSGPACK_USE_CPP03) -}; - -struct size_overflow : public unpack_error { - explicit size_overflow(const std::string& msg) - :unpack_error(msg) {} -#if !defined(MSGPACK_USE_CPP03) - explicit size_overflow(const char* msg) - :unpack_error(msg) {} -#endif -}; - -struct array_size_overflow : public size_overflow { - array_size_overflow(const std::string& msg) - :size_overflow(msg) {} -#if !defined(MSGPACK_USE_CPP03) - array_size_overflow(const char* msg) - :size_overflow(msg) {} -#endif -}; - -struct map_size_overflow : public size_overflow { - map_size_overflow(const std::string& msg) - :size_overflow(msg) {} -#if !defined(MSGPACK_USE_CPP03) - map_size_overflow(const char* msg) - :size_overflow(msg) {} -#endif -}; - -struct str_size_overflow : public size_overflow { - str_size_overflow(const std::string& msg) - :size_overflow(msg) {} -#if !defined(MSGPACK_USE_CPP03) - str_size_overflow(const char* msg) - :size_overflow(msg) {} -#endif -}; - -struct bin_size_overflow : public size_overflow { - bin_size_overflow(const std::string& msg) - :size_overflow(msg) {} -#if !defined(MSGPACK_USE_CPP03) - bin_size_overflow(const char* msg) - :size_overflow(msg) {} -#endif -}; - -struct ext_size_overflow : public size_overflow { - ext_size_overflow(const std::string& msg) - :size_overflow(msg) {} -#if !defined(MSGPACK_USE_CPP03) - ext_size_overflow(const char* msg) - :size_overflow(msg) {} -#endif -}; - -struct depth_size_overflow : public size_overflow { - depth_size_overflow(const std::string& msg) - :size_overflow(msg) {} -#if !defined(MSGPACK_USE_CPP03) - depth_size_overflow(const char* msg) - :size_overflow(msg) {} -#endif -}; - -class unpack_limit { -public: - unpack_limit( - std::size_t array = 0xffffffff, - std::size_t map = 0xffffffff, - std::size_t str = 0xffffffff, - std::size_t bin = 0xffffffff, - std::size_t ext = 0xffffffff, - std::size_t depth = 0xffffffff) - :array_(array), - map_(map), - str_(str), - bin_(bin), - ext_(ext), - depth_(depth) {} - std::size_t array() const { return array_; } - std::size_t map() const { return map_; } - std::size_t str() const { return str_; } - std::size_t bin() const { return bin_; } - std::size_t ext() const { return ext_; } - std::size_t depth() const { return depth_; } - -private: - std::size_t array_; - std::size_t map_; - std::size_t str_; - std::size_t bin_; - std::size_t ext_; - std::size_t depth_; -}; - -namespace detail { - -class unpack_user { -public: - unpack_user(unpack_reference_func f = nullptr, - void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()) - :m_func(f), m_user_data(user_data), m_limit(limit) {} - msgpack::zone const& zone() const { return *m_zone; } - msgpack::zone& zone() { return *m_zone; } - void set_zone(msgpack::zone& zone) { m_zone = &zone; } - bool referenced() const { return m_referenced; } - void set_referenced(bool referenced) { m_referenced = referenced; } - unpack_reference_func reference_func() const { return m_func; } - void* user_data() const { return m_user_data; } - unpack_limit const& limit() const { return m_limit; } - unpack_limit& limit() { return m_limit; } - -private: - msgpack::zone* m_zone; - bool m_referenced; - unpack_reference_func m_func; - void* m_user_data; - unpack_limit m_limit; -}; - -inline void unpack_uint8(uint8_t d, msgpack::object& o) -{ o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } - -inline void unpack_uint16(uint16_t d, msgpack::object& o) -{ o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } - -inline void unpack_uint32(uint32_t d, msgpack::object& o) -{ o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } - -inline void unpack_uint64(uint64_t d, msgpack::object& o) -{ o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } - -inline void unpack_int8(int8_t d, msgpack::object& o) -{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } - else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } } - -inline void unpack_int16(int16_t d, msgpack::object& o) -{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } - else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } } - -inline void unpack_int32(int32_t d, msgpack::object& o) -{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } - else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } } - -inline void unpack_int64(int64_t d, msgpack::object& o) -{ if(d >= 0) { o.type = msgpack::type::POSITIVE_INTEGER; o.via.u64 = d; } - else { o.type = msgpack::type::NEGATIVE_INTEGER; o.via.i64 = d; } } - -inline void unpack_float(float d, msgpack::object& o) -{ o.type = msgpack::type::FLOAT; o.via.f64 = d; } - -inline void unpack_double(double d, msgpack::object& o) -{ o.type = msgpack::type::FLOAT; o.via.f64 = d; } - -inline void unpack_nil(msgpack::object& o) -{ o.type = msgpack::type::NIL; } - -inline void unpack_true(msgpack::object& o) -{ o.type = msgpack::type::BOOLEAN; o.via.boolean = true; } - -inline void unpack_false(msgpack::object& o) -{ o.type = msgpack::type::BOOLEAN; o.via.boolean = false; } - -struct unpack_array { - void operator()(unpack_user& u, uint32_t n, msgpack::object& o) const { - if (n > u.limit().array()) throw msgpack::array_size_overflow("array size overflow"); - o.type = msgpack::type::ARRAY; - o.via.array.size = 0; - o.via.array.ptr = static_cast(u.zone().allocate_align(n*sizeof(msgpack::object))); - } -}; - -inline void unpack_array_item(msgpack::object& c, msgpack::object const& o) -{ -#if defined(__GNUC__) && !defined(__clang__) - std::memcpy(&c.via.array.ptr[c.via.array.size++], &o, sizeof(msgpack::object)); -#else /* __GNUC__ && !__clang__ */ - c.via.array.ptr[c.via.array.size++] = o; -#endif /* __GNUC__ && !__clang__ */ -} - -struct unpack_map { - void operator()(unpack_user& u, uint32_t n, msgpack::object& o) const { - if (n > u.limit().map()) throw msgpack::map_size_overflow("map size overflow"); - o.type = msgpack::type::MAP; - o.via.map.size = 0; - o.via.map.ptr = static_cast(u.zone().allocate_align(n*sizeof(msgpack::object_kv))); - } -}; - -inline void unpack_map_item(msgpack::object& c, msgpack::object const& k, msgpack::object const& v) -{ -#if defined(__GNUC__) && !defined(__clang__) - std::memcpy(&c.via.map.ptr[c.via.map.size].key, &k, sizeof(msgpack::object)); - std::memcpy(&c.via.map.ptr[c.via.map.size].val, &v, sizeof(msgpack::object)); -#else /* __GNUC__ && !__clang__ */ - c.via.map.ptr[c.via.map.size].key = k; - c.via.map.ptr[c.via.map.size].val = v; -#endif /* __GNUC__ && !__clang__ */ - ++c.via.map.size; -} - -inline void unpack_str(unpack_user& u, const char* p, uint32_t l, msgpack::object& o) -{ - o.type = msgpack::type::STR; - if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { - o.via.str.ptr = p; - u.set_referenced(true); - } - else { - if (l > u.limit().str()) throw msgpack::str_size_overflow("str size overflow"); - char* tmp = static_cast(u.zone().allocate_align(l)); - std::memcpy(tmp, p, l); - o.via.str.ptr = tmp; - } - o.via.str.size = l; -} - -inline void unpack_bin(unpack_user& u, const char* p, uint32_t l, msgpack::object& o) -{ - o.type = msgpack::type::BIN; - if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { - o.via.bin.ptr = p; - u.set_referenced(true); - } - else { - if (l > u.limit().bin()) throw msgpack::bin_size_overflow("bin size overflow"); - char* tmp = static_cast(u.zone().allocate_align(l)); - std::memcpy(tmp, p, l); - o.via.bin.ptr = tmp; - } - o.via.bin.size = l; -} - -inline void unpack_ext(unpack_user& u, const char* p, std::size_t l, msgpack::object& o) -{ - o.type = msgpack::type::EXT; - if (u.reference_func() && u.reference_func()(o.type, l, u.user_data())) { - o.via.ext.ptr = p; - u.set_referenced(true); - } - else { - if (l > u.limit().ext()) throw msgpack::ext_size_overflow("ext size overflow"); - char* tmp = static_cast(u.zone().allocate_align(l)); - std::memcpy(tmp, p, l); - o.via.ext.ptr = tmp; - } - o.via.ext.size = static_cast(l - 1); -} - - -class unpack_stack { -public: - msgpack::object const& obj() const { return m_obj; } - msgpack::object& obj() { return m_obj; } - void set_obj(msgpack::object const& obj) { m_obj = obj; } - std::size_t count() const { return m_count; } - void set_count(std::size_t count) { m_count = count; } - std::size_t decr_count() { return --m_count; } - uint32_t container_type() const { return m_container_type; } - void set_container_type(uint32_t container_type) { m_container_type = container_type; } - msgpack::object const& map_key() const { return m_map_key; } - void set_map_key(msgpack::object const& map_key) { m_map_key = map_key; } -private: - msgpack::object m_obj; - std::size_t m_count; - uint32_t m_container_type; - msgpack::object m_map_key; -}; - -inline void init_count(void* buffer) -{ -#if defined(MSGPACK_USE_CPP03) - *reinterpret_cast(buffer) = 1; -#else // defined(MSGPACK_USE_CPP03) - new (buffer) std::atomic(1); -#endif // defined(MSGPACK_USE_CPP03) -} - -inline void decr_count(void* buffer) -{ -#if defined(MSGPACK_USE_CPP03) - if(_msgpack_sync_decr_and_fetch(reinterpret_cast(buffer)) == 0) { - free(buffer); - } -#else // defined(MSGPACK_USE_CPP03) - if (--*reinterpret_cast*>(buffer) == 0) { - free(buffer); - } -#endif // defined(MSGPACK_USE_CPP03) -} - -inline void incr_count(void* buffer) -{ -#if defined(MSGPACK_USE_CPP03) - _msgpack_sync_incr_and_fetch(reinterpret_cast(buffer)); -#else // defined(MSGPACK_USE_CPP03) - ++*reinterpret_cast*>(buffer); -#endif // defined(MSGPACK_USE_CPP03) -} - -#if defined(MSGPACK_USE_CPP03) -inline _msgpack_atomic_counter_t get_count(void* buffer) -{ - return *reinterpret_cast(buffer); -} -#else // defined(MSGPACK_USE_CPP03) -inline std::atomic const& get_count(void* buffer) -{ - return *reinterpret_cast*>(buffer); -} -#endif // defined(MSGPACK_USE_CPP03) - -struct fix_tag { - char f1[65]; // FIXME unique size is required. or use is_same meta function. -}; - -template -struct value { - typedef T type; -}; -template <> -struct value { - typedef uint32_t type; -}; - -template -inline void load(uint32_t& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - dst = static_cast(*reinterpret_cast(n)) & 0x0f; -} - -template -inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - dst = static_cast(*reinterpret_cast(n)); -} - -template -inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - _msgpack_load16(T, n, &dst); -} - -template -inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - _msgpack_load32(T, n, &dst); -} - -template -inline void load(T& dst, const char* n, typename msgpack::enable_if::type* = nullptr) { - _msgpack_load64(T, n, &dst); -} - -class context { -public: - context(unpack_reference_func f, void* user_data, unpack_limit const& limit) - :m_trail(0), m_user(f, user_data, limit), m_cs(MSGPACK_CS_HEADER) - { - m_stack.reserve(MSGPACK_EMBED_STACK_SIZE); - m_stack.push_back(unpack_stack()); - } - - void init() - { - m_cs = MSGPACK_CS_HEADER; - m_trail = 0; - m_stack.resize(1); - m_stack[0].set_obj(msgpack::object()); - } - - msgpack::object const& data() const - { - return m_stack[0].obj(); - } - - unpack_user& user() - { - return m_user; - } - - unpack_user const& user() const - { - return m_user; - } - - int execute(const char* data, std::size_t len, std::size_t& off); - -private: - template - static uint32_t next_cs(T p) - { - return static_cast(*p) & 0x1f; - } - - template - int push_aggregate( - Func const& f, - uint32_t container_type, - msgpack::object& obj, - const char* load_pos, - std::size_t& off) { - typename value::type tmp; - load(tmp, load_pos); - f(m_user, tmp, m_stack.back().obj()); - if(tmp == 0) { - obj = m_stack.back().obj(); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_stack.back().set_container_type(container_type); - m_stack.back().set_count(tmp); - if (m_stack.size() <= m_user.limit().depth()) { - m_stack.push_back(unpack_stack()); - } - else { - throw msgpack::depth_size_overflow("depth size overflow"); - } - m_cs = MSGPACK_CS_HEADER; - ++m_current; - } - return 0; - } - - int push_item(msgpack::object& obj) { - bool finish = false; - while (!finish) { - if(m_stack.size() == 1) { - return 1; - } - unpack_stack& sp = *(m_stack.end() - 2); - switch(sp.container_type()) { - case MSGPACK_CT_ARRAY_ITEM: - unpack_array_item(sp.obj(), obj); - if(sp.decr_count() == 0) { - obj = sp.obj(); - m_stack.pop_back(); - } - else { - finish = true; - } - break; - case MSGPACK_CT_MAP_KEY: - sp.set_map_key(obj); - sp.set_container_type(MSGPACK_CT_MAP_VALUE); - finish = true; - break; - case MSGPACK_CT_MAP_VALUE: - unpack_map_item(sp.obj(), sp.map_key(), obj); - if(sp.decr_count() == 0) { - obj = sp.obj(); - m_stack.pop_back(); - } - else { - sp.set_container_type(MSGPACK_CT_MAP_KEY); - finish = true; - } - break; - default: - return -1; - } - } - return 0; - } - - int push_proc(msgpack::object& obj, std::size_t& off) { - int ret = push_item(obj); - if (ret > 0) { - m_stack[0].set_obj(obj); - ++m_current; - /*printf("-- finish --\n"); */ - off = m_current - m_start; - } - else if (ret < 0) { - off = m_current - m_start; - } - else { - m_cs = MSGPACK_CS_HEADER; - ++m_current; - } - return ret; - } - - template - static void check_ext_size(std::size_t /*size*/) { - } - -private: - char const* m_start; - char const* m_current; - - std::size_t m_trail; - unpack_user m_user; - uint32_t m_cs; - std::vector m_stack; -}; - -template <> -inline void context::check_ext_size<4>(std::size_t size) { - if (size == 0xffffffff) throw msgpack::ext_size_overflow("ext size overflow"); -} - -inline int context::execute(const char* data, std::size_t len, std::size_t& off) -{ - assert(len >= off); - - m_start = data; - m_current = data + off; - const char* const pe = data + len; - const char* n = nullptr; - - msgpack::object obj; - - if(m_current == pe) { - off = m_current - m_start; - return 0; - } - bool fixed_trail_again = false; - do { - if (m_cs == MSGPACK_CS_HEADER) { - fixed_trail_again = false; - int selector = *reinterpret_cast(m_current); - if (0x00 <= selector && selector <= 0x7f) { // Positive Fixnum - unpack_uint8(*reinterpret_cast(m_current), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } else if(0xe0 <= selector && selector <= 0xff) { // Negative Fixnum - unpack_int8(*reinterpret_cast(m_current), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } else if (0xc4 <= selector && selector <= 0xdf) { - const uint32_t trail[] = { - 1, // bin 8 0xc4 - 2, // bin 16 0xc5 - 4, // bin 32 0xc6 - 1, // ext 8 0xc7 - 2, // ext 16 0xc8 - 4, // ext 32 0xc9 - 4, // float 32 0xca - 8, // float 64 0xcb - 1, // uint 8 0xcc - 2, // uint 16 0xcd - 4, // uint 32 0xce - 8, // uint 64 0xcf - 1, // int 8 0xd0 - 2, // int 16 0xd1 - 4, // int 32 0xd2 - 8, // int 64 0xd3 - 2, // fixext 1 0xd4 - 3, // fixext 2 0xd5 - 5, // fixext 4 0xd6 - 9, // fixext 8 0xd7 - 17,// fixext 16 0xd8 - 1, // str 8 0xd9 - 2, // str 16 0xda - 4, // str 32 0xdb - 2, // array 16 0xdc - 4, // array 32 0xdd - 2, // map 16 0xde - 4, // map 32 0xdf - }; - m_trail = trail[selector - 0xc4]; - m_cs = next_cs(m_current); - fixed_trail_again = true; - } else if(0xa0 <= selector && selector <= 0xbf) { // FixStr - m_trail = static_cast(*m_current) & 0x1f; - if(m_trail == 0) { - unpack_str(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_STR_VALUE; - fixed_trail_again = true; - } - - } else if(0x90 <= selector && selector <= 0x9f) { // FixArray - int ret = push_aggregate( - unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, m_current, off); - if (ret != 0) return ret; - } else if(0x80 <= selector && selector <= 0x8f) { // FixMap - int ret = push_aggregate( - unpack_map(), MSGPACK_CT_MAP_KEY, obj, m_current, off); - if (ret != 0) return ret; - } else if(selector == 0xc2) { // false - unpack_false(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } else if(selector == 0xc3) { // true - unpack_true(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } else if(selector == 0xc0) { // nil - unpack_nil(obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } else { - off = m_current - m_start; - return -1; - } - // end MSGPACK_CS_HEADER - } - if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) { - if (fixed_trail_again) { - ++m_current; - fixed_trail_again = false; - } - if(static_cast(pe - m_current) < m_trail) { - off = m_current - m_start; - return 0; - } - n = m_current; - m_current += m_trail - 1; - switch(m_cs) { - //case MSGPACK_CS_ - //case MSGPACK_CS_ - case MSGPACK_CS_FLOAT: { - union { uint32_t i; float f; } mem; - load(mem.i, n); - unpack_float(mem.f, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_DOUBLE: { - union { uint64_t i; double f; } mem; - load(mem.i, n); -#if defined(__arm__) && !(__ARM_EABI__) // arm-oabi - // https://github.com/msgpack/msgpack-perl/pull/1 - mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); -#endif - unpack_double(mem.f, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_UINT_8: { - uint8_t tmp; - load(tmp, n); - unpack_uint8(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_UINT_16: { - uint16_t tmp; - load(tmp, n); - unpack_uint16(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_UINT_32: { - uint32_t tmp; - load(tmp, n); - unpack_uint32(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_UINT_64: { - uint64_t tmp; - load(tmp, n); - unpack_uint64(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_INT_8: { - int8_t tmp; - load(tmp, n); - unpack_int8(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_INT_16: { - int16_t tmp; - load(tmp, n); - unpack_int16(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_INT_32: { - int32_t tmp; - load(tmp, n); - unpack_int32(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_INT_64: { - int64_t tmp; - load(tmp, n); - unpack_int64(tmp, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_FIXEXT_1: { - unpack_ext(m_user, n, 1+1, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_FIXEXT_2: { - unpack_ext(m_user, n, 2+1, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_FIXEXT_4: { - unpack_ext(m_user, n, 4+1, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_FIXEXT_8: { - unpack_ext(m_user, n, 8+1, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_FIXEXT_16: { - unpack_ext(m_user, n, 16+1, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_STR_8: { - uint8_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_str(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_STR_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_CS_BIN_8: { - uint8_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_bin(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_BIN_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_CS_EXT_8: { - uint8_t tmp; - load(tmp, n); - m_trail = tmp + 1; - if(m_trail == 0) { - unpack_ext(m_user, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_EXT_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_CS_STR_16: { - uint16_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_str(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_STR_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_CS_BIN_16: { - uint16_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_bin(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_BIN_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_CS_EXT_16: { - uint16_t tmp; - load(tmp, n); - m_trail = tmp + 1; - if(m_trail == 0) { - unpack_ext(m_user, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_EXT_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_CS_STR_32: { - uint32_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_str(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_STR_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_CS_BIN_32: { - uint32_t tmp; - load(tmp, n); - m_trail = tmp; - if(m_trail == 0) { - unpack_bin(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_BIN_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_CS_EXT_32: { - uint32_t tmp; - load(tmp, n); - check_ext_size(tmp); - m_trail = tmp; - ++m_trail; - if(m_trail == 0) { - unpack_ext(m_user, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } - else { - m_cs = MSGPACK_ACS_EXT_VALUE; - fixed_trail_again = true; - } - } break; - case MSGPACK_ACS_STR_VALUE: { - unpack_str(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_ACS_BIN_VALUE: { - unpack_bin(m_user, n, static_cast(m_trail), obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_ACS_EXT_VALUE: { - unpack_ext(m_user, n, m_trail, obj); - int ret = push_proc(obj, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_ARRAY_16: { - int ret = push_aggregate( - unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, n, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_ARRAY_32: { - /* FIXME security guard */ - int ret = push_aggregate( - unpack_array(), MSGPACK_CT_ARRAY_ITEM, obj, n, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_MAP_16: { - int ret = push_aggregate( - unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off); - if (ret != 0) return ret; - } break; - case MSGPACK_CS_MAP_32: { - /* FIXME security guard */ - int ret = push_aggregate( - unpack_map(), MSGPACK_CT_MAP_KEY, obj, n, off); - if (ret != 0) return ret; - } break; - default: - off = m_current - m_start; - return -1; - } - } - } while(m_current != pe); - - off = m_current - m_start; - return 0; -} - -} // detail - - -class unpacked { -public: - unpacked() {} - - unpacked(msgpack::object const& obj, msgpack::unique_ptr z) : - m_obj(obj), m_zone(msgpack::move(z)) { } - - void set(msgpack::object const& obj) - { m_obj = obj; } - - const msgpack::object& get() const - { return m_obj; } - - msgpack::unique_ptr& zone() - { return m_zone; } - - const msgpack::unique_ptr& zone() const - { return m_zone; } - -private: - msgpack::object m_obj; - msgpack::unique_ptr m_zone; -}; - - -class unpacker { -public: - unpacker(unpack_reference_func f = &unpacker::default_reference_func, - void* user_data = nullptr, - std::size_t init_buffer_size = MSGPACK_UNPACKER_INIT_BUFFER_SIZE, - unpack_limit const& limit = unpack_limit()); - -#if !defined(MSGPACK_USE_CPP03) - unpacker(unpacker&& other); - unpacker& operator=(unpacker&& other); -#endif // !defined(MSGPACK_USE_CPP03) - - ~unpacker(); - -public: - /*! 1. reserve buffer. at least `size' bytes of capacity will be ready */ - void reserve_buffer(std::size_t size = MSGPACK_UNPACKER_RESERVE_SIZE); - - /*! 2. read data to the buffer() up to buffer_capacity() bytes */ - char* buffer(); - std::size_t buffer_capacity() const; - - /*! 3. specify the number of bytes actually copied */ - void buffer_consumed(std::size_t size); - - /*! 4. repeat next() until it retunrs false */ - bool next(unpacked* result); - bool next(unpacked& result, bool& referenced); - bool next(unpacked& result); - - /*! 5. check if the size of message doesn't exceed assumption. */ - std::size_t message_size() const; - - // Basic usage of the unpacker is as following: - // - // unpacker pac; - // while( /* input is readable */ ) { - // - // // 1. - // pac.reserve_buffer(32*1024); - // - // // 2. - // std::size_t bytes = input.readsome(pac.buffer(), pac.buffer_capacity()); - // - // // error handling ... - // - // // 3. - // pac.buffer_consumed(bytes); - // - // // 4. - // unpacked result; - // while(pac.next(&result)) { - // // do some with the object with the zone. - // object obj = result.get(); - // std::auto_ptr z = result.zone(); - // on_message(obj, z); - // - // //// boost::shared_ptr is also usable: - // // boost::shared_ptr life(z.release()); - // // on_message(result.get(), life); - // } - // - // // 5. - // if(pac.message_size() > 10*1024*1024) { - // throw std::runtime_error("message is too large"); - // } - // } - // - - /*! for backward compatibility */ - bool execute(); - - /*! for backward compatibility */ - msgpack::object const& data(); - - /*! for backward compatibility */ - msgpack::zone* release_zone(); - - /*! for backward compatibility */ - void reset_zone(); - - /*! for backward compatibility */ - void reset(); - -public: - // These functions are usable when non-MessagePack message follows after - // MessagePack message. - std::size_t parsed_size() const; - - /*! get address of the buffer that is not parsed */ - char* nonparsed_buffer(); - std::size_t nonparsed_size() const; - - /*! skip specified size of non-parsed buffer, leaving the buffer */ - // Note that the `size' argument must be smaller than nonparsed_size() - void skip_nonparsed_buffer(std::size_t size); - - /*! remove unparsed buffer from unpacker */ - // Note that reset() leaves non-parsed buffer. - void remove_nonparsed_buffer(); - -private: - void expand_buffer(std::size_t size); - int execute_imp(); - bool flush_zone(); - static bool default_reference_func(msgpack::type::object_type type, std::size_t len, void*); - -private: - char* m_buffer; - std::size_t m_used; - std::size_t m_free; - std::size_t m_off; - std::size_t m_parsed; - msgpack::unique_ptr m_z; - std::size_t m_initial_buffer_size; - detail::context m_ctx; - -#if defined(MSGPACK_USE_CPP03) -private: - unpacker(const unpacker&); - unpacker& operator=(const unpacker&); -#else // defined(MSGPACK_USE_CPP03) - unpacker(const unpacker&) = delete; - unpacker& operator=(const unpacker&) = delete; -#endif // defined(MSGPACK_USE_CPP03) -}; - -#if !defined(MSGPACK_USE_CPP03) - -unpacked unpack( - const char* data, std::size_t len, std::size_t& off, bool& referenced, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); -unpacked unpack( - const char* data, std::size_t len, std::size_t& off, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); -unpacked unpack( - const char* data, std::size_t len, bool& referenced, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); -unpacked unpack( - const char* data, std::size_t len, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); - -#endif // !defined(MSGPACK_USE_CPP03) - - -void unpack(unpacked& result, - const char* data, std::size_t len, std::size_t& off, bool& referenced, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); -void unpack(unpacked& result, - const char* data, std::size_t len, std::size_t& off, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); -void unpack(unpacked& result, - const char* data, std::size_t len, bool& referenced, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); - -void unpack(unpacked& result, - const char* data, std::size_t len, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); - -msgpack::object unpack( - msgpack::zone& z, - const char* data, std::size_t len, std::size_t& off, bool& referenced, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); -msgpack::object unpack( - msgpack::zone& z, - const char* data, std::size_t len, std::size_t& off, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); -msgpack::object unpack( - msgpack::zone& z, - const char* data, std::size_t len, bool& referenced, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); -msgpack::object unpack( - msgpack::zone& z, - const char* data, std::size_t len, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); - - -// obsolete -void unpack(unpacked* result, - const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()); - - -// for internal use -typedef enum { - UNPACK_SUCCESS = 2, - UNPACK_EXTRA_BYTES = 1, - UNPACK_CONTINUE = 0, - UNPACK_PARSE_ERROR = -1 -} unpack_return; - -inline unpacker::unpacker(unpack_reference_func f, - void* user_data, - std::size_t initial_buffer_size, - unpack_limit const& limit) - :m_z(new msgpack::zone), m_ctx(f, user_data, limit) -{ - if(initial_buffer_size < COUNTER_SIZE) { - initial_buffer_size = COUNTER_SIZE; - } - - char* buffer = static_cast(::malloc(initial_buffer_size)); - if(!buffer) { - throw std::bad_alloc(); - } - - m_buffer = buffer; - m_used = COUNTER_SIZE; - m_free = initial_buffer_size - m_used; - m_off = COUNTER_SIZE; - m_parsed = 0; - m_initial_buffer_size = initial_buffer_size; - - detail::init_count(m_buffer); - - m_ctx.init(); - m_ctx.user().set_zone(*m_z); - m_ctx.user().set_referenced(false); -} - -#if !defined(MSGPACK_USE_CPP03) -// Move constructor and move assignment operator - -inline unpacker::unpacker(unpacker&& other) - :m_buffer(other.m_buffer), - m_used(other.m_used), - m_free(other.m_free), - m_off(other.m_off), - m_parsed(other.m_parsed), - m_z(std::move(other.m_z)), - m_initial_buffer_size(other.m_initial_buffer_size), - m_ctx(other.m_ctx) { - other.m_buffer = nullptr; -} - -inline unpacker& unpacker::operator=(unpacker&& other) { - this->~unpacker(); - new (this) unpacker(std::move(other)); - return *this; -} - -#endif // !defined(MSGPACK_USE_CPP03) - - -inline unpacker::~unpacker() -{ - // These checks are required for move operations. - if (m_buffer) detail::decr_count(m_buffer); -} - - -inline void unpacker::reserve_buffer(std::size_t size) -{ - if(m_free >= size) return; - expand_buffer(size); -} - -inline void unpacker::expand_buffer(std::size_t size) -{ - if(m_used == m_off && detail::get_count(m_buffer) == 1 - && !m_ctx.user().referenced()) { - // rewind buffer - m_free += m_used - COUNTER_SIZE; - m_used = COUNTER_SIZE; - m_off = COUNTER_SIZE; - - if(m_free >= size) return; - } - - if(m_off == COUNTER_SIZE) { - std::size_t next_size = (m_used + m_free) * 2; // include COUNTER_SIZE - while(next_size < size + m_used) { - std::size_t tmp_next_size = next_size * 2; - if (tmp_next_size <= next_size) { - next_size = size + m_used; - break; - } - next_size = tmp_next_size; - } - - char* tmp = static_cast(::realloc(m_buffer, next_size)); - if(!tmp) { - throw std::bad_alloc(); - } - - m_buffer = tmp; - m_free = next_size - m_used; - - } else { - std::size_t next_size = m_initial_buffer_size; // include COUNTER_SIZE - std::size_t not_parsed = m_used - m_off; - while(next_size < size + not_parsed + COUNTER_SIZE) { - std::size_t tmp_next_size = next_size * 2; - if (tmp_next_size <= next_size) { - next_size = size + not_parsed + COUNTER_SIZE; - break; - } - next_size = tmp_next_size; - } - - char* tmp = static_cast(::malloc(next_size)); - if(!tmp) { - throw std::bad_alloc(); - } - - detail::init_count(tmp); - - std::memcpy(tmp+COUNTER_SIZE, m_buffer + m_off, not_parsed); - - if(m_ctx.user().referenced()) { - try { - m_z->push_finalizer(&detail::decr_count, m_buffer); - } - catch (...) { - ::free(tmp); - throw; - } - m_ctx.user().set_referenced(false); - } else { - detail::decr_count(m_buffer); - } - - m_buffer = tmp; - m_used = not_parsed + COUNTER_SIZE; - m_free = next_size - m_used; - m_off = COUNTER_SIZE; - } -} - -inline char* unpacker::buffer() -{ - return m_buffer + m_used; -} - -inline std::size_t unpacker::buffer_capacity() const -{ - return m_free; -} - -inline void unpacker::buffer_consumed(std::size_t size) -{ - m_used += size; - m_free -= size; -} - -inline bool unpacker::next(unpacked& result, bool& referenced) -{ - referenced = false; - int ret = execute_imp(); - if(ret < 0) { - throw msgpack::parse_error("parse error"); - } - - if(ret == 0) { - result.zone().reset(); - result.set(object()); - return false; - - } else { - referenced = m_ctx.user().referenced(); - result.zone().reset( release_zone() ); - result.set(data()); - reset(); - return true; - } -} - -inline bool unpacker::next(unpacked& result) -{ - bool referenced; - return next(result, referenced); -} - -inline bool unpacker::next(unpacked* result) -{ - return next(*result); -} - - -inline bool unpacker::execute() -{ - int ret = execute_imp(); - if(ret < 0) { - throw msgpack::parse_error("parse error"); - } else if(ret == 0) { - return false; - } else { - return true; - } -} - -inline int unpacker::execute_imp() -{ - std::size_t off = m_off; - int ret = m_ctx.execute(m_buffer, m_used, m_off); - if(m_off > off) { - m_parsed += m_off - off; - } - return ret; -} - -inline msgpack::object const& unpacker::data() -{ - return m_ctx.data(); -} - -inline msgpack::zone* unpacker::release_zone() -{ - if(!flush_zone()) { - return nullptr; - } - - msgpack::zone* r = new msgpack::zone; - msgpack::zone* old = m_z.release(); - m_z.reset(r); - m_ctx.user().set_zone(*m_z); - - return old; -} - -inline void unpacker::reset_zone() -{ - m_z->clear(); -} - -inline bool unpacker::flush_zone() -{ - if(m_ctx.user().referenced()) { - try { - m_z->push_finalizer(&detail::decr_count, m_buffer); - } catch (...) { - return false; - } - m_ctx.user().set_referenced(false); - - detail::incr_count(m_buffer); - } - - return true; -} - -inline void unpacker::reset() -{ - m_ctx.init(); - // don't reset referenced flag - m_parsed = 0; -} - -inline std::size_t unpacker::message_size() const -{ - return m_parsed - m_off + m_used; -} - -inline std::size_t unpacker::parsed_size() const -{ - return m_parsed; -} - -inline char* unpacker::nonparsed_buffer() -{ - return m_buffer + m_off; -} - -inline std::size_t unpacker::nonparsed_size() const -{ - return m_used - m_off; -} - -inline void unpacker::skip_nonparsed_buffer(std::size_t size) -{ - m_off += size; -} - -inline void unpacker::remove_nonparsed_buffer() -{ - m_used = m_off; -} - -namespace detail { - -inline unpack_return -unpack_imp(const char* data, std::size_t len, std::size_t& off, - msgpack::zone& result_zone, msgpack::object& result, bool& referenced, - unpack_reference_func f = nullptr, void* user_data = nullptr, - unpack_limit const& limit = unpack_limit()) -{ - std::size_t noff = off; - - if(len <= noff) { - // FIXME - return UNPACK_CONTINUE; - } - - detail::context ctx(f, user_data, limit); - ctx.init(); - - ctx.user().set_zone(result_zone); - ctx.user().set_referenced(false); - referenced = false; - - int e = ctx.execute(data, len, noff); - if(e < 0) { - return UNPACK_PARSE_ERROR; - } - - referenced = ctx.user().referenced(); - off = noff; - - if(e == 0) { - return UNPACK_CONTINUE; - } - - result = ctx.data(); - - if(noff < len) { - return UNPACK_EXTRA_BYTES; - } - - return UNPACK_SUCCESS; -} - -} // detail - -// reference version - -#if !defined(MSGPACK_USE_CPP03) - -inline unpacked unpack( - const char* data, std::size_t len, std::size_t& off, bool& referenced, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - msgpack::object obj; - msgpack::unique_ptr z(new msgpack::zone); - referenced = false; - unpack_return ret = detail::unpack_imp( - data, len, off, *z, obj, referenced, f, user_data, limit); - - switch(ret) { - case UNPACK_SUCCESS: - return unpacked(obj, msgpack::move(z)); - case UNPACK_EXTRA_BYTES: - return unpacked(obj, msgpack::move(z)); - case UNPACK_CONTINUE: - throw msgpack::insufficient_bytes("insufficient bytes"); - case UNPACK_PARSE_ERROR: - default: - throw msgpack::parse_error("parse error"); - } - return unpacked(); -} - -inline unpacked unpack( - const char* data, std::size_t len, std::size_t& off, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - bool referenced; - return unpack(data, len, off, referenced, f, user_data, limit); -} - -inline unpacked unpack( - const char* data, std::size_t len, bool& referenced, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - std::size_t off = 0; - return unpack(data, len, off, referenced, f, user_data, limit); -} - -inline unpacked unpack( - const char* data, std::size_t len, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - bool referenced; - std::size_t off = 0; - return unpack(data, len, off, referenced, f, user_data, limit); -} - -#endif // !defined(MSGPACK_USE_CPP03) - -inline void unpack(unpacked& result, - const char* data, std::size_t len, std::size_t& off, bool& referenced, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - msgpack::object obj; - msgpack::unique_ptr z(new msgpack::zone); - referenced = false; - unpack_return ret = detail::unpack_imp( - data, len, off, *z, obj, referenced, f, user_data, limit); - - switch(ret) { - case UNPACK_SUCCESS: - result.set(obj); - result.zone() = msgpack::move(z); - return; - case UNPACK_EXTRA_BYTES: - result.set(obj); - result.zone() = msgpack::move(z); - return; - case UNPACK_CONTINUE: - throw msgpack::insufficient_bytes("insufficient bytes"); - case UNPACK_PARSE_ERROR: - default: - throw msgpack::parse_error("parse error"); - } -} - -inline void unpack(unpacked& result, - const char* data, std::size_t len, std::size_t& off, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - bool referenced; - unpack(result, data, len, off, referenced, f, user_data, limit); -} - -inline void unpack(unpacked& result, - const char* data, std::size_t len, bool& referenced, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - std::size_t off = 0; - unpack(result, data, len, off, referenced, f, user_data, limit); -} - -inline void unpack(unpacked& result, - const char* data, std::size_t len, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - bool referenced; - std::size_t off = 0; - unpack(result, data, len, off, referenced, f, user_data, limit); -} - - -inline msgpack::object unpack( - msgpack::zone& z, - const char* data, std::size_t len, std::size_t& off, bool& referenced, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - msgpack::object obj; - referenced = false; - unpack_return ret = detail::unpack_imp( - data, len, off, z, obj, referenced, f, user_data, limit); - - switch(ret) { - case UNPACK_SUCCESS: - return obj; - case UNPACK_EXTRA_BYTES: - return obj; - case UNPACK_CONTINUE: - throw msgpack::insufficient_bytes("insufficient bytes"); - case UNPACK_PARSE_ERROR: - default: - throw msgpack::parse_error("parse error"); - } - return obj; -} - -inline msgpack::object unpack( - msgpack::zone& z, - const char* data, std::size_t len, std::size_t& off, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - bool referenced; - return unpack(z, data, len, off, referenced, f, user_data, limit); -} - -inline msgpack::object unpack( - msgpack::zone& z, - const char* data, std::size_t len, bool& referenced, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - std::size_t off = 0; - return unpack(z, data, len, off, referenced, f, user_data, limit); -} - -inline msgpack::object unpack( - msgpack::zone& z, - const char* data, std::size_t len, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - bool referenced; - std::size_t off = 0; - return unpack(z, data, len, off, referenced, f, user_data, limit); -} - -// obsolete -// pointer version -inline void unpack(unpacked* result, - const char* data, std::size_t len, std::size_t* off, bool* referenced, - unpack_reference_func f, void* user_data, unpack_limit const& limit) -{ - if (off) - if (referenced) unpack(*result, data, len, *off, *referenced, f, user_data, limit); - else unpack(*result, data, len, *off, f, user_data, limit); - else - if (referenced) unpack(*result, data, len, *referenced, f, user_data, limit); - else unpack(*result, data, len, f, user_data, limit); -} - -inline bool unpacker::default_reference_func(msgpack::type::object_type /*type*/, std::size_t /*len*/, void*) -{ - return true; -} - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - - -#endif /* msgpack/unpack.hpp */ diff --git a/deps/msgpack/msgpack/util.h b/deps/msgpack/msgpack/util.h deleted file mode 100644 index 89b98a1..0000000 --- a/deps/msgpack/msgpack/util.h +++ /dev/null @@ -1,23 +0,0 @@ -/* - * MessagePack for C utilities - * - * Copyright (C) 2014 FURUHASHI Sadayuki - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef MSGPACK_UTIL_H -#define MSGPACK_UTIL_H - -#define MSGPACK_UNUSED(a) (void)(a) - -#endif /* MSGPACK_UTIL_H */ diff --git a/deps/msgpack/msgpack/version.hpp b/deps/msgpack/msgpack/version.hpp deleted file mode 100644 index d1ccd89..0000000 --- a/deps/msgpack/msgpack/version.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/* - * MessagePack for C++ version information - * - * Copyright (C) 2008-2013 FURUHASHI Sadayuki and Takatoshi Kondo - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef MSGPACK_VERSION_HPP -#define MSGPACK_VERSION_HPP - -#include "version_master.h" - -#define MSGPACK_STR(v) #v -#define MSGPACK_VERSION_I(maj, min, rev) MSGPACK_STR(maj) "." MSGPACK_STR(min) "." MSGPACK_STR(rev) - -#define MSGPACK_VERSION MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION) - -inline const char* msgpack_version(void) { - return MSGPACK_VERSION; -} - -inline int msgpack_version_major(void) { - return MSGPACK_VERSION_MAJOR; -} - -inline int msgpack_version_minor(void) { - return MSGPACK_VERSION_MINOR; -} - -inline int msgpack_version_revision(void) { - return MSGPACK_VERSION_REVISION; -} - -#endif /* msgpack/version.hpp */ diff --git a/deps/msgpack/msgpack/version_master.h b/deps/msgpack/msgpack/version_master.h deleted file mode 100644 index 4fa83ee..0000000 --- a/deps/msgpack/msgpack/version_master.h +++ /dev/null @@ -1,3 +0,0 @@ -#define MSGPACK_VERSION_MAJOR 1 -#define MSGPACK_VERSION_MINOR 1 -#define MSGPACK_VERSION_REVISION 0 diff --git a/deps/msgpack/msgpack/versioning.hpp b/deps/msgpack/msgpack/versioning.hpp deleted file mode 100644 index 4626352..0000000 --- a/deps/msgpack/msgpack/versioning.hpp +++ /dev/null @@ -1,77 +0,0 @@ -/* - * MessagePack for C++ version switcher - * - * Copyright (C) 2014 KONDO Takatoshi - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#ifndef MSGPACK_VERSIONING_HPP -#define MSGPACK_VERSIONING_HPP - -#if !defined(MSGPACK_DEFAULT_API_VERSION) -#define MSGPACK_DEFAULT_API_VERSION 1 -#endif - -#define MSGPACK_DEFAULT_API_NS MSGPACK_PP_CAT(v, MSGPACK_DEFAULT_API_VERSION) - -#if MSGPACK_DEFAULT_API_VERSION == 1 -#define MSGPACK_PP_ENABLE_NS_v1 () -//#elif MSGPACK_DEFAULT_API_VERSION == 2 -//#define MSGPACK_PP_ENABLE_NS_v2 () -#else -#error -#endif - -#define MSGPACK_PP_CAT(a, ...) MSGPACK_PP_PRIMITIVE_CAT(a, __VA_ARGS__) -#define MSGPACK_PP_PRIMITIVE_CAT(a, ...) a ## __VA_ARGS__ - -#define MSGPACK_PP_IIF(c) MSGPACK_PP_PRIMITIVE_CAT(MSGPACK_PP_IIF_, c) -#define MSGPACK_PP_IIF_0(t, ...) __VA_ARGS__ -#define MSGPACK_PP_IIF_1(t, ...) t - -#define MSGPACK_PP_PROBE(x) x, 1 - -#if defined(_MSC_VER) - -#define MSGPACK_PP_MSVC_VA_ARGS_WORKAROUND(define, args) define args -#define MSGPACK_PP_CHECK(...) MSGPACK_PP_MSVC_VA_ARGS_WORKAROUND(MSGPACK_PP_CHECK_N, (__VA_ARGS__, 0)) -#define MSGPACK_PP_CHECK_N(x, n, ...) n - -#else // defined(__MSC_VER) - -#define MSGPACK_PP_CHECK(...) MSGPACK_PP_CHECK_N(__VA_ARGS__, 0) -#define MSGPACK_PP_CHECK_N(x, n, ...) n - -#endif // defined(__MSC_VER) - - -#define MSGPACK_PP_NS_ENABLED_PROBE(ns) MSGPACK_PP_NS_ENABLED_PROBE_PROXY( MSGPACK_PP_ENABLE_NS_##ns ) -#define MSGPACK_PP_NS_ENABLED_PROBE_PROXY(...) MSGPACK_PP_NS_ENABLED_PROBE_PRIMIVIE(__VA_ARGS__) -#define MSGPACK_PP_NS_ENABLED_PROBE_PRIMIVIE(x) MSGPACK_PP_NS_ENABLED_PROBE_COMBINE_ x -#define MSGPACK_PP_NS_ENABLED_PROBE_COMBINE_(...) MSGPACK_PP_PROBE(~) - -#define MSGPACK_PP_IS_NS_ENABLED(ns) MSGPACK_PP_CHECK(MSGPACK_PP_NS_ENABLED_PROBE(ns)) - -#if __cplusplus < 201103 -#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_PP_IIF(MSGPACK_PP_IS_NS_ENABLED(ns)) \ - (namespace ns{}; using namespace ns; namespace ns, \ - namespace ns) - -#else // __cplusplus < 201103 - -#define MSGPACK_API_VERSION_NAMESPACE(ns) MSGPACK_PP_IIF(MSGPACK_PP_IS_NS_ENABLED(ns)) \ - (inline namespace ns, namespace ns) - -#endif // __cplusplus < 201103 - -#endif // MSGPACK_VERSIONING_HPP diff --git a/deps/msgpack/msgpack/vrefbuffer.hpp b/deps/msgpack/msgpack/vrefbuffer.hpp deleted file mode 100644 index 5ea953d..0000000 --- a/deps/msgpack/msgpack/vrefbuffer.hpp +++ /dev/null @@ -1,300 +0,0 @@ -// -// MessagePack for C++ zero-copy buffer implementation -// -// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_VREFBUFFER_HPP -#define MSGPACK_VREFBUFFER_HPP - -#include "msgpack/versioning.hpp" - -#include - -#ifndef MSGPACK_VREFBUFFER_REF_SIZE -#define MSGPACK_VREFBUFFER_REF_SIZE 32 -#endif - -#ifndef MSGPACK_VREFBUFFER_CHUNK_SIZE -#define MSGPACK_VREFBUFFER_CHUNK_SIZE 8192 -#endif - -#ifndef _WIN32 -#include -#else -struct iovec { - void *iov_base; - size_t iov_len; -}; -#endif - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -namespace detail { - // int64, uint64, double - std::size_t const packer_max_buffer_size = 9; -} // detail - -class vrefbuffer { -private: - struct chunk { - chunk* next; - }; - struct inner_buffer { - size_t free; - char* ptr; - chunk* head; - }; -public: - vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE, - size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE) - :m_ref_size(std::max(ref_size, detail::packer_max_buffer_size + 1)), - m_chunk_size(chunk_size) - { - size_t nfirst = (sizeof(iovec) < 72/2) ? - 72 / sizeof(iovec) : 8; - - iovec* array = static_cast(::malloc( - sizeof(iovec) * nfirst)); - if(!array) { - throw std::bad_alloc(); - } - - m_tail = array; - m_end = array + nfirst; - m_array = array; - - chunk* c = static_cast(::malloc(sizeof(chunk) + chunk_size)); - if(!c) { - ::free(array); - throw std::bad_alloc(); - } - inner_buffer* const ib = &m_inner_buffer; - - ib->free = chunk_size; - ib->ptr = reinterpret_cast(c) + sizeof(chunk); - ib->head = c; - c->next = nullptr; - - } - - ~vrefbuffer() - { - chunk* c = m_inner_buffer.head; - while(true) { - chunk* n = c->next; - ::free(c); - if(n != NULL) { - c = n; - } else { - break; - } - } - ::free(m_array); - } - -public: - void write(const char* buf, size_t len) - { - if(len < m_ref_size) { - append_copy(buf, len); - } else { - append_ref(buf, len); - } - } - - void append_ref(const char* buf, size_t len) - { - if(m_tail == m_end) { - const size_t nused = m_tail - m_array; - const size_t nnext = nused * 2; - - iovec* nvec = static_cast(::realloc( - m_array, sizeof(iovec)*nnext)); - if(!nvec) { - throw std::bad_alloc(); - } - - m_array = nvec; - m_end = nvec + nnext; - m_tail = nvec + nused; - } - - m_tail->iov_base = const_cast(buf); - m_tail->iov_len = len; - ++m_tail; - } - - void append_copy(const char* buf, size_t len) - { - inner_buffer* const ib = &m_inner_buffer; - - if(ib->free < len) { - size_t sz = m_chunk_size; - if(sz < len) { - sz = len; - } - - chunk* c = static_cast(::malloc(sizeof(chunk) + sz)); - if(!c) { - throw std::bad_alloc(); - } - - c->next = ib->head; - ib->head = c; - ib->free = sz; - ib->ptr = reinterpret_cast(c) + sizeof(chunk); - } - - char* m = ib->ptr; - std::memcpy(m, buf, len); - ib->free -= len; - ib->ptr += len; - - if(m_tail != m_array && m == - static_cast( - const_cast((m_tail - 1)->iov_base) - ) + (m_tail - 1)->iov_len) { - (m_tail - 1)->iov_len += len; - return; - } else { - append_ref( m, len); - } - } - - const struct iovec* vector() const - { - return m_array; - } - - size_t vector_size() const - { - return m_tail - m_array; - } - - void migrate(vrefbuffer* to) - { - size_t sz = m_chunk_size; - - chunk* empty = static_cast(::malloc(sizeof(chunk) + sz)); - if(!empty) { - throw std::bad_alloc(); - } - - empty->next = nullptr; - - const size_t nused = m_tail - m_array; - if(to->m_tail + nused < m_end) { - const size_t tosize = to->m_tail - to->m_array; - const size_t reqsize = nused + tosize; - size_t nnext = (to->m_end - to->m_array) * 2; - while(nnext < reqsize) { - size_t tmp_nnext = nnext * 2; - if (tmp_nnext <= nnext) { - nnext = reqsize; - break; - } - nnext = tmp_nnext; - } - - iovec* nvec = static_cast(::realloc( - to->m_array, sizeof(iovec)*nnext)); - if(!nvec) { - ::free(empty); - throw std::bad_alloc(); - } - - to->m_array = nvec; - to->m_end = nvec + nnext; - to->m_tail = nvec + tosize; - } - - std::memcpy(to->m_tail, m_array, sizeof(iovec)*nused); - - to->m_tail += nused; - m_tail = m_array; - - - inner_buffer* const ib = &m_inner_buffer; - inner_buffer* const toib = &to->m_inner_buffer; - - chunk* last = ib->head; - while(last->next) { - last = last->next; - } - last->next = toib->head; - toib->head = ib->head; - - if(toib->free < ib->free) { - toib->free = ib->free; - toib->ptr = ib->ptr; - } - - ib->head = empty; - ib->free = sz; - ib->ptr = reinterpret_cast(empty) + sizeof(chunk); - - } - - void clear() - { - chunk* c = m_inner_buffer.head->next; - chunk* n; - while(c) { - n = c->next; - ::free(c); - c = n; - } - - inner_buffer* const ib = &m_inner_buffer; - c = ib->head; - c->next = nullptr; - ib->free = m_chunk_size; - ib->ptr = reinterpret_cast(c) + sizeof(chunk); - - m_tail = m_array; - } - -#if defined(MSGPACK_USE_CPP03) -private: - vrefbuffer(const vrefbuffer&); - vrefbuffer& operator=(const vrefbuffer&); -#else // defined(MSGPACK_USE_CPP03) - vrefbuffer(const vrefbuffer&) = delete; - vrefbuffer& operator=(const vrefbuffer&) = delete; -#endif // defined(MSGPACK_USE_CPP03) - -private: - iovec* m_tail; - iovec* m_end; - iovec* m_array; - - size_t m_ref_size; - size_t m_chunk_size; - - inner_buffer m_inner_buffer; - -}; - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif /* msgpack/vrefbuffer.hpp */ diff --git a/deps/msgpack/msgpack/zbuffer.hpp b/deps/msgpack/msgpack/zbuffer.hpp deleted file mode 100644 index 688a70b..0000000 --- a/deps/msgpack/msgpack/zbuffer.hpp +++ /dev/null @@ -1,175 +0,0 @@ -// -// MessagePack for C++ deflate buffer implementation -// -// Copyright (C) 2010-2013 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_ZBUFFER_HPP -#define MSGPACK_ZBUFFER_HPP - -#include "msgpack/versioning.hpp" - -#include -#include - -#ifndef MSGPACK_ZBUFFER_RESERVE_SIZE -#define MSGPACK_ZBUFFER_RESERVE_SIZE 512 -#endif - -#ifndef MSGPACK_ZBUFFER_INIT_SIZE -#define MSGPACK_ZBUFFER_INIT_SIZE 8192 -#endif - -namespace msgpack { - -/// @cond -MSGPACK_API_VERSION_NAMESPACE(v1) { -/// @endcond - -class zbuffer { -public: - zbuffer(int level = Z_DEFAULT_COMPRESSION, - size_t init_size = MSGPACK_ZBUFFER_INIT_SIZE) - : m_data(nullptr), m_init_size(init_size) - { - m_stream.zalloc = Z_NULL; - m_stream.zfree = Z_NULL; - m_stream.opaque = Z_NULL; - m_stream.next_out = Z_NULL; - m_stream.avail_out = 0; - if(deflateInit(&m_stream, level) != Z_OK) { - throw std::bad_alloc(); - } - } - - ~zbuffer() - { - deflateEnd(&m_stream); - ::free(m_data); - } - -public: - void write(const char* buf, size_t len) - { - m_stream.next_in = reinterpret_cast(const_cast(buf)); - m_stream.avail_in = len; - - do { - if(m_stream.avail_out < MSGPACK_ZBUFFER_RESERVE_SIZE) { - if(!expand()) { - throw std::bad_alloc(); - } - } - - if(deflate(&m_stream, Z_NO_FLUSH) != Z_OK) { - throw std::bad_alloc(); - } - } while(m_stream.avail_in > 0); - } - - char* flush() - { - while(true) { - switch(deflate(&m_stream, Z_FINISH)) { - case Z_STREAM_END: - return m_data; - case Z_OK: - if(!expand()) { - throw std::bad_alloc(); - } - break; - default: - throw std::bad_alloc(); - } - } - } - - char* data() - { - return m_data; - } - - const char* data() const - { - return m_data; - } - - size_t size() const - { - return reinterpret_cast(m_stream.next_out) - m_data; - } - - void reset() - { - if(deflateReset(&m_stream) != Z_OK) { - throw std::bad_alloc(); - } - reset_buffer(); - } - - void reset_buffer() - { - m_stream.avail_out += reinterpret_cast(m_stream.next_out) - m_data; - m_stream.next_out = reinterpret_cast(m_data); - } - - char* release_buffer() - { - char* tmp = m_data; - m_data = nullptr; - m_stream.next_out = nullptr; - m_stream.avail_out = 0; - return tmp; - } - -private: - bool expand() - { - size_t used = reinterpret_cast(m_stream.next_out) - m_data; - size_t csize = used + m_stream.avail_out; - size_t nsize = (csize == 0) ? m_init_size : csize * 2; - - char* tmp = static_cast(::realloc(m_data, nsize)); - if(tmp == nullptr) { - return false; - } - - m_data = tmp; - m_stream.next_out = reinterpret_cast(tmp + used); - m_stream.avail_out = nsize - used; - - return true; - } -#if defined(MSGPACK_USE_CPP03) -private: - zbuffer(const zbuffer&); - zbuffer& operator=(const zbuffer&); -#else // defined(MSGPACK_USE_CPP03) - zbuffer(const zbuffer&) = delete; - zbuffer& operator=(const zbuffer&) = delete; -#endif // defined(MSGPACK_USE_CPP03) - -private: - z_stream m_stream; - char* m_data; - size_t m_init_size; -}; - -/// @cond -} // MSGPACK_API_VERSION_NAMESPACE(v1) -/// @endcond - -} // namespace msgpack - -#endif /* msgpack/zbuffer.hpp */ diff --git a/deps/msgpack/msgpack/zone.hpp b/deps/msgpack/msgpack/zone.hpp deleted file mode 100644 index 9a23af9..0000000 --- a/deps/msgpack/msgpack/zone.hpp +++ /dev/null @@ -1,29 +0,0 @@ -// -// MessagePack for C++ memory pool -// -// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// -#ifndef MSGPACK_ZONE_HPP -#define MSGPACK_ZONE_HPP - -#include "msgpack/cpp_config.hpp" - -#if defined(MSGPACK_USE_CPP03) -#include "detail/cpp03_zone.hpp" -#else // MSGPACK_USE_CPP03 -#include "detail/cpp11_zone.hpp" -#endif // MSGPACK_USE_CPP03 - -#endif // MSGPACK_ZONE_HPP diff --git a/deps/msgpack/objectc.c b/deps/msgpack/objectc.c deleted file mode 100644 index 16b5db0..0000000 --- a/deps/msgpack/objectc.c +++ /dev/null @@ -1,299 +0,0 @@ -/* - * MessagePack for C dynamic typing routine - * - * Copyright (C) 2008-2009 FURUHASHI Sadayuki - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -#include "msgpack/object.h" -#include "msgpack/pack.h" -#include -#include - -#if !defined(_MSC_VER) || _MSC_VER >= 1800 -#include -#endif - - -int msgpack_pack_object(msgpack_packer* pk, msgpack_object d) -{ - switch(d.type) { - case MSGPACK_OBJECT_NIL: - return msgpack_pack_nil(pk); - - case MSGPACK_OBJECT_BOOLEAN: - if(d.via.boolean) { - return msgpack_pack_true(pk); - } else { - return msgpack_pack_false(pk); - } - - case MSGPACK_OBJECT_POSITIVE_INTEGER: - return msgpack_pack_uint64(pk, d.via.u64); - - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - return msgpack_pack_int64(pk, d.via.i64); - - case MSGPACK_OBJECT_FLOAT: - return msgpack_pack_double(pk, d.via.f64); - - case MSGPACK_OBJECT_STR: - { - int ret = msgpack_pack_str(pk, d.via.str.size); - if(ret < 0) { return ret; } - return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size); - } - - case MSGPACK_OBJECT_BIN: - { - int ret = msgpack_pack_bin(pk, d.via.bin.size); - if(ret < 0) { return ret; } - return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size); - } - - case MSGPACK_OBJECT_EXT: - { - int ret = msgpack_pack_ext(pk, d.via.ext.size, d.via.ext.type); - if(ret < 0) { return ret; } - return msgpack_pack_ext_body(pk, d.via.ext.ptr, d.via.ext.size); - } - - case MSGPACK_OBJECT_ARRAY: - { - int ret = msgpack_pack_array(pk, d.via.array.size); - if(ret < 0) { - return ret; - } - else { - msgpack_object* o = d.via.array.ptr; - msgpack_object* const oend = d.via.array.ptr + d.via.array.size; - for(; o != oend; ++o) { - ret = msgpack_pack_object(pk, *o); - if(ret < 0) { return ret; } - } - - return 0; - } - } - - case MSGPACK_OBJECT_MAP: - { - int ret = msgpack_pack_map(pk, d.via.map.size); - if(ret < 0) { - return ret; - } - else { - msgpack_object_kv* kv = d.via.map.ptr; - msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size; - for(; kv != kvend; ++kv) { - ret = msgpack_pack_object(pk, kv->key); - if(ret < 0) { return ret; } - ret = msgpack_pack_object(pk, kv->val); - if(ret < 0) { return ret; } - } - - return 0; - } - } - - default: - return -1; - } -} - - -void msgpack_object_print(FILE* out, msgpack_object o) -{ - switch(o.type) { - case MSGPACK_OBJECT_NIL: - fprintf(out, "nil"); - break; - - case MSGPACK_OBJECT_BOOLEAN: - fprintf(out, (o.via.boolean ? "true" : "false")); - break; - - case MSGPACK_OBJECT_POSITIVE_INTEGER: -#if defined(PRIu64) - fprintf(out, "%" PRIu64, o.via.u64); -#else - if (o.via.u64 > ULONG_MAX) - fprintf(out, "over 4294967295"); - else - fprintf(out, "%lu", (unsigned long)o.via.u64); -#endif - break; - - case MSGPACK_OBJECT_NEGATIVE_INTEGER: -#if defined(PRIi64) - fprintf(out, "%" PRIi64, o.via.i64); -#else - if (o.via.i64 > LONG_MAX) - fprintf(out, "over +2147483647"); - else if (o.via.i64 < LONG_MIN) - fprintf(out, "under -2147483648"); - else - fprintf(out, "%ld", (signed long)o.via.i64); -#endif - break; - - case MSGPACK_OBJECT_FLOAT: - fprintf(out, "%f", o.via.f64); - break; - - case MSGPACK_OBJECT_STR: - fprintf(out, "\""); - fwrite(o.via.str.ptr, o.via.str.size, 1, out); - fprintf(out, "\""); - break; - - case MSGPACK_OBJECT_BIN: - fprintf(out, "\""); - fwrite(o.via.bin.ptr, o.via.bin.size, 1, out); - fprintf(out, "\""); - break; - - case MSGPACK_OBJECT_EXT: -#if defined(PRIi8) - fprintf(out, "(ext: %" PRIi8 ")", o.via.ext.type); -#else - fprintf(out, "(ext: %d)", (int)o.via.ext.type); -#endif - fprintf(out, "\""); - fwrite(o.via.ext.ptr, o.via.ext.size, 1, out); - fprintf(out, "\""); - break; - - case MSGPACK_OBJECT_ARRAY: - fprintf(out, "["); - if(o.via.array.size != 0) { - msgpack_object* p = o.via.array.ptr; - msgpack_object* const pend = o.via.array.ptr + o.via.array.size; - msgpack_object_print(out, *p); - ++p; - for(; p < pend; ++p) { - fprintf(out, ", "); - msgpack_object_print(out, *p); - } - } - fprintf(out, "]"); - break; - - case MSGPACK_OBJECT_MAP: - fprintf(out, "{"); - if(o.via.map.size != 0) { - msgpack_object_kv* p = o.via.map.ptr; - msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; - msgpack_object_print(out, p->key); - fprintf(out, "=>"); - msgpack_object_print(out, p->val); - ++p; - for(; p < pend; ++p) { - fprintf(out, ", "); - msgpack_object_print(out, p->key); - fprintf(out, "=>"); - msgpack_object_print(out, p->val); - } - } - fprintf(out, "}"); - break; - - default: - // FIXME -#if defined(PRIu64) - fprintf(out, "#", o.type, o.via.u64); -#else - if (o.via.u64 > ULONG_MAX) - fprintf(out, "#", o.type); - else - fprintf(out, "#", o.type, (unsigned long)o.via.u64); -#endif - - } -} - -bool msgpack_object_equal(const msgpack_object x, const msgpack_object y) -{ - if(x.type != y.type) { return false; } - - switch(x.type) { - case MSGPACK_OBJECT_NIL: - return true; - - case MSGPACK_OBJECT_BOOLEAN: - return x.via.boolean == y.via.boolean; - - case MSGPACK_OBJECT_POSITIVE_INTEGER: - return x.via.u64 == y.via.u64; - - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - return x.via.i64 == y.via.i64; - - case MSGPACK_OBJECT_FLOAT: - return x.via.f64 == y.via.f64; - - case MSGPACK_OBJECT_STR: - return x.via.str.size == y.via.str.size && - memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; - - case MSGPACK_OBJECT_BIN: - return x.via.bin.size == y.via.bin.size && - memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; - - case MSGPACK_OBJECT_EXT: - return x.via.ext.size == y.via.ext.size && - x.via.ext.type == y.via.ext.type && - memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; - - case MSGPACK_OBJECT_ARRAY: - if(x.via.array.size != y.via.array.size) { - return false; - } else if(x.via.array.size == 0) { - return true; - } else { - msgpack_object* px = x.via.array.ptr; - msgpack_object* const pxend = x.via.array.ptr + x.via.array.size; - msgpack_object* py = y.via.array.ptr; - do { - if(!msgpack_object_equal(*px, *py)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } - - case MSGPACK_OBJECT_MAP: - if(x.via.map.size != y.via.map.size) { - return false; - } else if(x.via.map.size == 0) { - return true; - } else { - msgpack_object_kv* px = x.via.map.ptr; - msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size; - msgpack_object_kv* py = y.via.map.ptr; - do { - if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) { - return false; - } - ++px; - ++py; - } while(px < pxend); - return true; - } - - default: - return false; - } -} diff --git a/deps/msgpack/src/objectc.c b/deps/msgpack/src/objectc.c new file mode 100644 index 0000000..c33ab2b --- /dev/null +++ b/deps/msgpack/src/objectc.c @@ -0,0 +1,550 @@ +/* + * MessagePack for C dynamic typing routine + * + * Copyright (C) 2008-2009 FURUHASHI Sadayuki + * + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + */ +#if defined(_KERNEL_MODE) +# undef _NO_CRT_STDIO_INLINE +# define _NO_CRT_STDIO_INLINE +#endif + +#include "msgpack/object.h" +#include "msgpack/pack.h" +#include + +#include +#include + +#if defined(_MSC_VER) +#if _MSC_VER >= 1800 +#include +#else +#define PRIu64 "I64u" +#define PRIi64 "I64i" +#define PRIi8 "i" +#endif +#else +#include +#endif + +#if defined(_KERNEL_MODE) +# undef snprintf +# define snprintf _snprintf +#endif + +int msgpack_pack_object(msgpack_packer* pk, msgpack_object d) +{ + switch(d.type) { + case MSGPACK_OBJECT_NIL: + return msgpack_pack_nil(pk); + + case MSGPACK_OBJECT_BOOLEAN: + if(d.via.boolean) { + return msgpack_pack_true(pk); + } else { + return msgpack_pack_false(pk); + } + + case MSGPACK_OBJECT_POSITIVE_INTEGER: + return msgpack_pack_uint64(pk, d.via.u64); + + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + return msgpack_pack_int64(pk, d.via.i64); + + case MSGPACK_OBJECT_FLOAT32: + return msgpack_pack_float(pk, (float)d.via.f64); + + case MSGPACK_OBJECT_FLOAT64: + return msgpack_pack_double(pk, d.via.f64); + + case MSGPACK_OBJECT_STR: + { + int ret = msgpack_pack_str(pk, d.via.str.size); + if(ret < 0) { return ret; } + return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size); + } + + case MSGPACK_OBJECT_BIN: + { + int ret = msgpack_pack_bin(pk, d.via.bin.size); + if(ret < 0) { return ret; } + return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size); + } + + case MSGPACK_OBJECT_EXT: + { + int ret = msgpack_pack_ext(pk, d.via.ext.size, d.via.ext.type); + if(ret < 0) { return ret; } + return msgpack_pack_ext_body(pk, d.via.ext.ptr, d.via.ext.size); + } + + case MSGPACK_OBJECT_ARRAY: + { + int ret = msgpack_pack_array(pk, d.via.array.size); + if(ret < 0) { + return ret; + } + else { + msgpack_object* o = d.via.array.ptr; + msgpack_object* const oend = d.via.array.ptr + d.via.array.size; + for(; o != oend; ++o) { + ret = msgpack_pack_object(pk, *o); + if(ret < 0) { return ret; } + } + + return 0; + } + } + + case MSGPACK_OBJECT_MAP: + { + int ret = msgpack_pack_map(pk, d.via.map.size); + if(ret < 0) { + return ret; + } + else { + msgpack_object_kv* kv = d.via.map.ptr; + msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size; + for(; kv != kvend; ++kv) { + ret = msgpack_pack_object(pk, kv->key); + if(ret < 0) { return ret; } + ret = msgpack_pack_object(pk, kv->val); + if(ret < 0) { return ret; } + } + + return 0; + } + } + + default: + return -1; + } +} + +void msgpack_object_init_nil(msgpack_object* d) { + d->type = MSGPACK_OBJECT_NIL; +} + +void msgpack_object_init_boolean(msgpack_object* d, bool v) { + d->type = MSGPACK_OBJECT_BOOLEAN; + d->via.boolean = v; +} + +void msgpack_object_init_unsigned_integer(msgpack_object* d, uint64_t v) { + d->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + d->via.u64 = v; +} + +void msgpack_object_init_signed_integer(msgpack_object* d, int64_t v) { + if (v < 0) { + d->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; + d->via.i64 = v; + } + else { + d->type = MSGPACK_OBJECT_POSITIVE_INTEGER; + d->via.u64 = v; + } +} + +void msgpack_object_init_float32(msgpack_object* d, float v) { + d->type = MSGPACK_OBJECT_FLOAT32; + d->via.f64 = v; +} + +void msgpack_object_init_float64(msgpack_object* d, double v) { + d->type = MSGPACK_OBJECT_FLOAT64; + d->via.f64 = v; +} + +void msgpack_object_init_str(msgpack_object* d, const char* data, uint32_t size) { + d->type = MSGPACK_OBJECT_STR; + d->via.str.ptr = data; + d->via.str.size = size; +} + +void msgpack_object_init_bin(msgpack_object* d, const char* data, uint32_t size) { + d->type = MSGPACK_OBJECT_BIN; + d->via.bin.ptr = data; + d->via.bin.size = size; +} + +void msgpack_object_init_ext(msgpack_object* d, int8_t type, const char* data, uint32_t size) { + d->type = MSGPACK_OBJECT_EXT; + d->via.ext.type = type; + d->via.ext.ptr = data; + d->via.ext.size = size; +} + +void msgpack_object_init_array(msgpack_object* d, msgpack_object* data, uint32_t size) { + d->type = MSGPACK_OBJECT_ARRAY; + d->via.array.ptr = data; + d->via.array.size = size; +} + +void msgpack_object_init_map(msgpack_object* d, msgpack_object_kv* data, uint32_t size) { + d->type = MSGPACK_OBJECT_MAP; + d->via.map.ptr = data; + d->via.map.size = size; +} + +#if !defined(_KERNEL_MODE) + +static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size) +{ + size_t i; + for (i = 0; i < size; ++i) { + if (ptr[i] == '"') { + fputs("\\\"", out); + } else if (isprint((unsigned char)ptr[i])) { + fputc(ptr[i], out); + } else { + fprintf(out, "\\x%02x", (unsigned char)ptr[i]); + } + } +} + +void msgpack_object_print(FILE* out, msgpack_object o) +{ + switch(o.type) { + case MSGPACK_OBJECT_NIL: + fprintf(out, "nil"); + break; + + case MSGPACK_OBJECT_BOOLEAN: + fprintf(out, (o.via.boolean ? "true" : "false")); + break; + + case MSGPACK_OBJECT_POSITIVE_INTEGER: +#if defined(PRIu64) + fprintf(out, "%" PRIu64, o.via.u64); +#else + if (o.via.u64 > ULONG_MAX) + fprintf(out, "over 4294967295"); + else + fprintf(out, "%lu", (unsigned long)o.via.u64); +#endif + break; + + case MSGPACK_OBJECT_NEGATIVE_INTEGER: +#if defined(PRIi64) + fprintf(out, "%" PRIi64, o.via.i64); +#else + if (o.via.i64 > LONG_MAX) + fprintf(out, "over +2147483647"); + else if (o.via.i64 < LONG_MIN) + fprintf(out, "under -2147483648"); + else + fprintf(out, "%ld", (signed long)o.via.i64); +#endif + break; + + case MSGPACK_OBJECT_FLOAT32: + case MSGPACK_OBJECT_FLOAT64: + fprintf(out, "%f", o.via.f64); + break; + + case MSGPACK_OBJECT_STR: + fprintf(out, "\""); + fwrite(o.via.str.ptr, o.via.str.size, 1, out); + fprintf(out, "\""); + break; + + case MSGPACK_OBJECT_BIN: + fprintf(out, "\""); + msgpack_object_bin_print(out, o.via.bin.ptr, o.via.bin.size); + fprintf(out, "\""); + break; + + case MSGPACK_OBJECT_EXT: +#if defined(PRIi8) + fprintf(out, "(ext: %" PRIi8 ")", o.via.ext.type); +#else + fprintf(out, "(ext: %d)", (int)o.via.ext.type); +#endif + fprintf(out, "\""); + msgpack_object_bin_print(out, o.via.ext.ptr, o.via.ext.size); + fprintf(out, "\""); + break; + + case MSGPACK_OBJECT_ARRAY: + fprintf(out, "["); + if(o.via.array.size != 0) { + msgpack_object* p = o.via.array.ptr; + msgpack_object* const pend = o.via.array.ptr + o.via.array.size; + msgpack_object_print(out, *p); + ++p; + for(; p < pend; ++p) { + fprintf(out, ", "); + msgpack_object_print(out, *p); + } + } + fprintf(out, "]"); + break; + + case MSGPACK_OBJECT_MAP: + fprintf(out, "{"); + if(o.via.map.size != 0) { + msgpack_object_kv* p = o.via.map.ptr; + msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; + msgpack_object_print(out, p->key); + fprintf(out, "=>"); + msgpack_object_print(out, p->val); + ++p; + for(; p < pend; ++p) { + fprintf(out, ", "); + msgpack_object_print(out, p->key); + fprintf(out, "=>"); + msgpack_object_print(out, p->val); + } + } + fprintf(out, "}"); + break; + + default: + // FIXME +#if defined(PRIu64) + fprintf(out, "#", o.type, o.via.u64); +#else + if (o.via.u64 > ULONG_MAX) + fprintf(out, "#", o.type); + else + fprintf(out, "#", o.type, (unsigned long)o.via.u64); +#endif + + } +} + +#endif + +#define MSGPACK_CHECKED_CALL(ret, func, aux_buffer, aux_buffer_size, ...) \ + ret = func(aux_buffer, aux_buffer_size, __VA_ARGS__); \ + if (ret <= 0 || ret >= (int)aux_buffer_size) return 0; \ + aux_buffer = aux_buffer + ret; \ + aux_buffer_size = aux_buffer_size - ret \ + +static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, const char *ptr, size_t size) +{ + size_t i; + char *aux_buffer = buffer; + size_t aux_buffer_size = buffer_size; + int ret; + + for (i = 0; i < size; ++i) { + if (ptr[i] == '"') { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\\""); + } else if (isprint((unsigned char)ptr[i])) { + if (aux_buffer_size > 0) { + memcpy(aux_buffer, ptr + i, 1); + aux_buffer = aux_buffer + 1; + aux_buffer_size = aux_buffer_size - 1; + } + } else { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\x%02x", (unsigned char)ptr[i]); + } + } + + return (int)(buffer_size - aux_buffer_size); +} + +int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o) +{ + char *aux_buffer = buffer; + size_t aux_buffer_size = buffer_size; + int ret; + switch(o.type) { + case MSGPACK_OBJECT_NIL: + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "nil"); + break; + + case MSGPACK_OBJECT_BOOLEAN: + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false")); + break; + + case MSGPACK_OBJECT_POSITIVE_INTEGER: +#if defined(PRIu64) + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64); +#else + if (o.via.u64 > ULONG_MAX) { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over 4294967295"); + } else { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64); + } +#endif + break; + + case MSGPACK_OBJECT_NEGATIVE_INTEGER: +#if defined(PRIi64) + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64); +#else + if (o.via.i64 > LONG_MAX) { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over +2147483647"); + } else if (o.via.i64 < LONG_MIN) { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "under -2147483648"); + } else { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64); + } +#endif + break; + + case MSGPACK_OBJECT_FLOAT32: + case MSGPACK_OBJECT_FLOAT64: + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%f", o.via.f64); + break; + + case MSGPACK_OBJECT_STR: + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); + if (o.via.str.size > 0) { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%.*s", (int)o.via.str.size, o.via.str.ptr); + } + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); + break; + + case MSGPACK_OBJECT_BIN: + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); + MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.bin.ptr, o.via.bin.size); + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); + break; + + case MSGPACK_OBJECT_EXT: +#if defined(PRIi8) + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %" PRIi8 ")", o.via.ext.type); +#else + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %d)", (int)o.via.ext.type); +#endif + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); + MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.ext.ptr, o.via.ext.size); + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\""); + break; + + case MSGPACK_OBJECT_ARRAY: + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "["); + if(o.via.array.size != 0) { + msgpack_object* p = o.via.array.ptr; + msgpack_object* const pend = o.via.array.ptr + o.via.array.size; + MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p); + ++p; + for(; p < pend; ++p) { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", "); + MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p); + } + } + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "]"); + break; + + case MSGPACK_OBJECT_MAP: + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "{"); + if(o.via.map.size != 0) { + msgpack_object_kv* p = o.via.map.ptr; + msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size; + MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key); + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>"); + MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val); + ++p; + for(; p < pend; ++p) { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", "); + MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key); + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>"); + MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val); + } + } + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "}"); + break; + + default: + // FIXME +#if defined(PRIu64) + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#", o.type, o.via.u64); +#else + if (o.via.u64 > ULONG_MAX) { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#", o.type); + } else { + MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#", o.type, (unsigned long)o.via.u64); + } +#endif + } + + return (int)(buffer_size - aux_buffer_size); +} + +#undef MSGPACK_CHECKED_CALL + +bool msgpack_object_equal(const msgpack_object x, const msgpack_object y) +{ + if(x.type != y.type) { return false; } + + switch(x.type) { + case MSGPACK_OBJECT_NIL: + return true; + + case MSGPACK_OBJECT_BOOLEAN: + return x.via.boolean == y.via.boolean; + + case MSGPACK_OBJECT_POSITIVE_INTEGER: + return x.via.u64 == y.via.u64; + + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + return x.via.i64 == y.via.i64; + + case MSGPACK_OBJECT_FLOAT32: + case MSGPACK_OBJECT_FLOAT64: + return x.via.f64 == y.via.f64; + + case MSGPACK_OBJECT_STR: + return x.via.str.size == y.via.str.size && + memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0; + + case MSGPACK_OBJECT_BIN: + return x.via.bin.size == y.via.bin.size && + memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0; + + case MSGPACK_OBJECT_EXT: + return x.via.ext.size == y.via.ext.size && + x.via.ext.type == y.via.ext.type && + memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0; + + case MSGPACK_OBJECT_ARRAY: + if(x.via.array.size != y.via.array.size) { + return false; + } else if(x.via.array.size == 0) { + return true; + } else { + msgpack_object* px = x.via.array.ptr; + msgpack_object* const pxend = x.via.array.ptr + x.via.array.size; + msgpack_object* py = y.via.array.ptr; + do { + if(!msgpack_object_equal(*px, *py)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + case MSGPACK_OBJECT_MAP: + if(x.via.map.size != y.via.map.size) { + return false; + } else if(x.via.map.size == 0) { + return true; + } else { + msgpack_object_kv* px = x.via.map.ptr; + msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size; + msgpack_object_kv* py = y.via.map.ptr; + do { + if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) { + return false; + } + ++px; + ++py; + } while(px < pxend); + return true; + } + + default: + return false; + } +} diff --git a/deps/msgpack/unpack.c b/deps/msgpack/src/unpack.c similarity index 76% rename from deps/msgpack/unpack.c rename to deps/msgpack/src/unpack.c index 446497c..c1280bf 100644 --- a/deps/msgpack/unpack.c +++ b/deps/msgpack/src/unpack.c @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #include "msgpack/unpack.h" #include "msgpack/unpack_define.h" @@ -26,7 +18,7 @@ typedef struct { - msgpack_zone* z; + msgpack_zone** z; bool referenced; } unpack_user; @@ -159,7 +151,7 @@ static inline int template_callback_int64(unpack_user* u, int64_t d, msgpack_obj static inline int template_callback_float(unpack_user* u, float d, msgpack_object* o) { MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_FLOAT; + o->type = MSGPACK_OBJECT_FLOAT32; o->via.f64 = d; return 0; } @@ -167,7 +159,7 @@ static inline int template_callback_float(unpack_user* u, float d, msgpack_objec static inline int template_callback_double(unpack_user* u, double d, msgpack_object* o) { MSGPACK_UNUSED(u); - o->type = MSGPACK_OBJECT_FLOAT; + o->type = MSGPACK_OBJECT_FLOAT64; o->via.f64 = d; return 0; } @@ -197,10 +189,37 @@ static inline int template_callback_false(unpack_user* u, msgpack_object* o) static inline int template_callback_array(unpack_user* u, unsigned int n, msgpack_object* o) { + size_t size; + // Let's leverage the fact that sizeof(msgpack_object) is a compile time constant + // to check for int overflows. + // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object) + // might not be constrained to 4GB on 64-bit systems +#if SIZE_MAX == UINT_MAX + if (n > SIZE_MAX/sizeof(msgpack_object)) + return MSGPACK_UNPACK_NOMEM_ERROR; +#endif + /* node-msgpack: conservative container cap (defense in depth). */ +#ifndef MSGPACK_NODE_MAX_CONTAINER +#define MSGPACK_NODE_MAX_CONTAINER 1000000u +#endif + if (n > MSGPACK_NODE_MAX_CONTAINER) + return MSGPACK_UNPACK_PARSE_ERROR; + o->type = MSGPACK_OBJECT_ARRAY; o->via.array.size = 0; - o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object)); - if(o->via.array.ptr == NULL) { return -1; } + + size = n * sizeof(msgpack_object); + + if (*u->z == NULL) { + *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(*u->z == NULL) { + return MSGPACK_UNPACK_NOMEM_ERROR; + } + } + + // Unsure whether size = 0 should be an error, and if so, what to return + o->via.array.ptr = (msgpack_object*)msgpack_zone_malloc(*u->z, size); + if(o->via.array.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } return 0; } @@ -218,10 +237,35 @@ static inline int template_callback_array_item(unpack_user* u, msgpack_object* c static inline int template_callback_map(unpack_user* u, unsigned int n, msgpack_object* o) { + size_t size; + // Let's leverage the fact that sizeof(msgpack_object_kv) is a compile time constant + // to check for int overflows + // Note - while n is constrained to 32-bit, the product of n * sizeof(msgpack_object) + // might not be constrained to 4GB on 64-bit systems + + // Note - this will always be false on 64-bit systems +#if SIZE_MAX == UINT_MAX + if (n > SIZE_MAX/sizeof(msgpack_object_kv)) + return MSGPACK_UNPACK_NOMEM_ERROR; +#endif + if (n > MSGPACK_NODE_MAX_CONTAINER) + return MSGPACK_UNPACK_PARSE_ERROR; + o->type = MSGPACK_OBJECT_MAP; o->via.map.size = 0; - o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(u->z, n*sizeof(msgpack_object_kv)); - if(o->via.map.ptr == NULL) { return -1; } + + size = n * sizeof(msgpack_object_kv); + + if (*u->z == NULL) { + *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(*u->z == NULL) { + return MSGPACK_UNPACK_NOMEM_ERROR; + } + } + + // Should size = 0 be an error? If so, what error to return? + o->via.map.ptr = (msgpack_object_kv*)msgpack_zone_malloc(*u->z, size); + if(o->via.map.ptr == NULL) { return MSGPACK_UNPACK_NOMEM_ERROR; } return 0; } @@ -241,8 +285,13 @@ static inline int template_callback_map_item(unpack_user* u, msgpack_object* c, static inline int template_callback_str(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { - MSGPACK_UNUSED(u); MSGPACK_UNUSED(b); + if (*u->z == NULL) { + *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(*u->z == NULL) { + return MSGPACK_UNPACK_NOMEM_ERROR; + } + } o->type = MSGPACK_OBJECT_STR; o->via.str.ptr = p; o->via.str.size = l; @@ -252,8 +301,13 @@ static inline int template_callback_str(unpack_user* u, const char* b, const cha static inline int template_callback_bin(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { - MSGPACK_UNUSED(u); MSGPACK_UNUSED(b); + if (*u->z == NULL) { + *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(*u->z == NULL) { + return MSGPACK_UNPACK_NOMEM_ERROR; + } + } o->type = MSGPACK_OBJECT_BIN; o->via.bin.ptr = p; o->via.bin.size = l; @@ -263,8 +317,16 @@ static inline int template_callback_bin(unpack_user* u, const char* b, const cha static inline int template_callback_ext(unpack_user* u, const char* b, const char* p, unsigned int l, msgpack_object* o) { - MSGPACK_UNUSED(u); MSGPACK_UNUSED(b); + if (l == 0) { + return MSGPACK_UNPACK_PARSE_ERROR; + } + if (*u->z == NULL) { + *u->z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); + if(*u->z == NULL) { + return MSGPACK_UNPACK_NOMEM_ERROR; + } + } o->type = MSGPACK_OBJECT_EXT; o->via.ext.type = *p; o->via.ext.ptr = p + 1; @@ -310,7 +372,6 @@ bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size) { char* buffer; void* ctx; - msgpack_zone* z; if(initial_buffer_size < COUNTER_SIZE) { initial_buffer_size = COUNTER_SIZE; @@ -327,26 +388,19 @@ bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size) return false; } - z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(z == NULL) { - free(ctx); - free(buffer); - return false; - } - mpac->buffer = buffer; mpac->used = COUNTER_SIZE; mpac->free = initial_buffer_size - mpac->used; mpac->off = COUNTER_SIZE; mpac->parsed = 0; mpac->initial_buffer_size = initial_buffer_size; - mpac->z = z; + mpac->z = NULL; mpac->ctx = ctx; init_count(mpac->buffer); template_init(CTX_CAST(mpac->ctx)); - CTX_CAST(mpac->ctx)->user.z = mpac->z; + CTX_CAST(mpac->ctx)->user.z = &mpac->z; CTX_CAST(mpac->ctx)->user.referenced = false; return true; @@ -396,7 +450,11 @@ bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size) if(mpac->off == COUNTER_SIZE) { char* tmp; - size_t next_size = (mpac->used + mpac->free) * 2; // include COUNTER_SIZE + size_t next_size; + if(size > SIZE_MAX - mpac->used) { + return false; + } + next_size = (mpac->used + mpac->free) * 2; // include COUNTER_SIZE while(next_size < size + mpac->used) { size_t tmp_next_size = next_size * 2; if (tmp_next_size <= next_size) { @@ -418,6 +476,9 @@ bool msgpack_unpacker_expand_buffer(msgpack_unpacker* mpac, size_t size) char* tmp; size_t next_size = mpac->initial_buffer_size; // include COUNTER_SIZE size_t not_parsed = mpac->used - mpac->off; + if(size > SIZE_MAX - not_parsed - COUNTER_SIZE) { + return false; + } while(next_size < size + not_parsed + COUNTER_SIZE) { size_t tmp_next_size = next_size * 2; if (tmp_next_size <= next_size) { @@ -473,21 +534,15 @@ msgpack_object msgpack_unpacker_data(msgpack_unpacker* mpac) msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac) { - msgpack_zone* r; - msgpack_zone* old; + msgpack_zone* old = mpac->z; + if (old == NULL) return NULL; if(!msgpack_unpacker_flush_zone(mpac)) { return NULL; } - r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - if(r == NULL) { - return NULL; - } - - old = mpac->z; - mpac->z = r; - CTX_CAST(mpac->ctx)->user.z = mpac->z; + mpac->z = NULL; + CTX_CAST(mpac->ctx)->user.z = &mpac->z; return old; } @@ -518,7 +573,8 @@ void msgpack_unpacker_reset(msgpack_unpacker* mpac) mpac->parsed = 0; } -msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpacked* result) +static inline msgpack_unpack_return unpacker_next(msgpack_unpacker* mpac, + msgpack_unpacked* result) { int ret; @@ -529,7 +585,7 @@ msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpa if(ret < 0) { result->zone = NULL; memset(&result->data, 0, sizeof(msgpack_object)); - return MSGPACK_UNPACK_PARSE_ERROR; + return (msgpack_unpack_return)ret; } if(ret == 0) { @@ -537,11 +593,40 @@ msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, msgpack_unpa } result->zone = msgpack_unpacker_release_zone(mpac); result->data = msgpack_unpacker_data(mpac); - msgpack_unpacker_reset(mpac); return MSGPACK_UNPACK_SUCCESS; } +msgpack_unpack_return msgpack_unpacker_next(msgpack_unpacker* mpac, + msgpack_unpacked* result) +{ + msgpack_unpack_return ret; + + ret = unpacker_next(mpac, result); + if (ret == MSGPACK_UNPACK_SUCCESS) { + msgpack_unpacker_reset(mpac); + } + + return ret; +} + +msgpack_unpack_return +msgpack_unpacker_next_with_size(msgpack_unpacker* mpac, + msgpack_unpacked* result, size_t *p_bytes) +{ + msgpack_unpack_return ret; + + ret = unpacker_next(mpac, result); + if (ret == MSGPACK_UNPACK_SUCCESS || ret == MSGPACK_UNPACK_CONTINUE) { + *p_bytes = mpac->parsed; + } + + if (ret == MSGPACK_UNPACK_SUCCESS) { + msgpack_unpacker_reset(mpac); + } + + return ret; +} msgpack_unpack_return msgpack_unpack(const char* data, size_t len, size_t* off, @@ -559,12 +644,12 @@ msgpack_unpack(const char* data, size_t len, size_t* off, template_context ctx; template_init(&ctx); - ctx.user.z = result_zone; + ctx.user.z = &result_zone; ctx.user.referenced = false; e = template_execute(&ctx, data, len, &noff); if(e < 0) { - return MSGPACK_UNPACK_PARSE_ERROR; + return (msgpack_unpack_return)e; } if(off != NULL) { *off = noff; } @@ -596,30 +681,24 @@ msgpack_unpack_next(msgpack_unpacked* result, return MSGPACK_UNPACK_CONTINUE; } - if (!result->zone) { - result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE); - } - - if (!result->zone) { - return MSGPACK_UNPACK_NOMEM_ERROR; - } - else { + { int e; template_context ctx; template_init(&ctx); - ctx.user.z = result->zone; + ctx.user.z = &result->zone; ctx.user.referenced = false; e = template_execute(&ctx, data, len, &noff); + + if(off != NULL) { *off = noff; } + if(e < 0) { msgpack_zone_free(result->zone); result->zone = NULL; - return MSGPACK_UNPACK_PARSE_ERROR; + return (msgpack_unpack_return)e; } - if(off != NULL) { *off = noff; } - if(e == 0) { return MSGPACK_UNPACK_CONTINUE; } diff --git a/deps/msgpack/version.c b/deps/msgpack/src/version.c similarity index 100% rename from deps/msgpack/version.c rename to deps/msgpack/src/version.c diff --git a/deps/msgpack/vrefbuffer.c b/deps/msgpack/src/vrefbuffer.c similarity index 81% rename from deps/msgpack/vrefbuffer.c rename to deps/msgpack/src/vrefbuffer.c index f756d9a..d14b719 100644 --- a/deps/msgpack/vrefbuffer.c +++ b/deps/msgpack/src/vrefbuffer.c @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #include "msgpack/vrefbuffer.h" #include @@ -30,19 +22,29 @@ bool msgpack_vrefbuffer_init(msgpack_vrefbuffer* vbuf, size_t ref_size, size_t chunk_size) { size_t nfirst; - struct iovec* array; + msgpack_iovec* array; msgpack_vrefbuffer_chunk* chunk; + if (ref_size == 0) { + ref_size = MSGPACK_VREFBUFFER_REF_SIZE; + } + if(chunk_size == 0) { + chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE; + } vbuf->chunk_size = chunk_size; vbuf->ref_size = ref_size > MSGPACK_PACKER_MAX_BUFFER_SIZE + 1 ? ref_size : MSGPACK_PACKER_MAX_BUFFER_SIZE + 1 ; - nfirst = (sizeof(struct iovec) < 72/2) ? - 72 / sizeof(struct iovec) : 8; + if((sizeof(msgpack_vrefbuffer_chunk) + chunk_size) < chunk_size) { + return false; + } + + nfirst = (sizeof(msgpack_iovec) < 72/2) ? + 72 / sizeof(msgpack_iovec) : 8; - array = (struct iovec*)malloc( - sizeof(struct iovec) * nfirst); + array = (msgpack_iovec*)malloc( + sizeof(msgpack_iovec) * nfirst); if(array == NULL) { return false; } @@ -112,8 +114,8 @@ int msgpack_vrefbuffer_append_ref(msgpack_vrefbuffer* vbuf, const size_t nused = (size_t)(vbuf->tail - vbuf->array); const size_t nnext = nused * 2; - struct iovec* nvec = (struct iovec*)realloc( - vbuf->array, sizeof(struct iovec)*nnext); + msgpack_iovec* nvec = (msgpack_iovec*)realloc( + vbuf->array, sizeof(msgpack_iovec)*nnext); if(nvec == NULL) { return -1; } @@ -143,6 +145,9 @@ int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf, sz = len; } + if((sizeof(msgpack_vrefbuffer_chunk) + sz) < sz){ + return -1; + } chunk = (msgpack_vrefbuffer_chunk*)malloc( sizeof(msgpack_vrefbuffer_chunk) + sz); if(chunk == NULL) { @@ -172,8 +177,13 @@ int msgpack_vrefbuffer_append_copy(msgpack_vrefbuffer* vbuf, int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to) { size_t sz = vbuf->chunk_size; + msgpack_vrefbuffer_chunk* empty; + + if((sizeof(msgpack_vrefbuffer_chunk) + sz) < sz){ + return -1; + } - msgpack_vrefbuffer_chunk* empty = (msgpack_vrefbuffer_chunk*)malloc( + empty = (msgpack_vrefbuffer_chunk*)malloc( sizeof(msgpack_vrefbuffer_chunk) + sz); if(empty == NULL) { return -1; @@ -184,7 +194,7 @@ int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to) { const size_t nused = (size_t)(vbuf->tail - vbuf->array); if(to->tail + nused < vbuf->end) { - struct iovec* nvec; + msgpack_iovec* nvec; const size_t tosize = (size_t)(to->tail - to->array); const size_t reqsize = nused + tosize; size_t nnext = (size_t)(to->end - to->array) * 2; @@ -197,8 +207,8 @@ int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to) nnext = tmp_nnext; } - nvec = (struct iovec*)realloc( - to->array, sizeof(struct iovec)*nnext); + nvec = (msgpack_iovec*)realloc( + to->array, sizeof(msgpack_iovec)*nnext); if(nvec == NULL) { free(empty); return -1; @@ -209,7 +219,7 @@ int msgpack_vrefbuffer_migrate(msgpack_vrefbuffer* vbuf, msgpack_vrefbuffer* to) to->tail = nvec + tosize; } - memcpy(to->tail, vbuf->array, sizeof(struct iovec)*nused); + memcpy(to->tail, vbuf->array, sizeof(msgpack_iovec)*nused); to->tail += nused; vbuf->tail = vbuf->array; diff --git a/deps/msgpack/zone.c b/deps/msgpack/src/zone.c similarity index 88% rename from deps/msgpack/zone.c rename to deps/msgpack/src/zone.c index 74c2bfa..372a1f5 100644 --- a/deps/msgpack/zone.c +++ b/deps/msgpack/src/zone.c @@ -3,17 +3,9 @@ * * Copyright (C) 2008-2009 FURUHASHI Sadayuki * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ #include "msgpack/zone.h" #include @@ -82,7 +74,7 @@ void* msgpack_zone_malloc_expand(msgpack_zone* zone, size_t size) while(sz < size) { size_t tmp_sz = sz * 2; if (tmp_sz <= sz) { - tmp_sz = size; + sz = size; break; } sz = tmp_sz; diff --git a/index.d.ts b/index.d.ts new file mode 100644 index 0000000..f768aff --- /dev/null +++ b/index.d.ts @@ -0,0 +1,51 @@ +// Type definitions for msgpack 2.0.0 +// Project: https://github.com/msgpack/msgpack-node + +/// + +import { EventEmitter } from 'events'; + +/** + * Serialize values to MessagePack. + * + * A single argument is packed as itself; two or more are packed as an array + * of that many elements. + */ +export function pack(...values: any[]): Buffer; + +/** + * Deserialize the first MessagePack value in `buf`. + * + * Returns `null` when the buffer holds an incomplete value, in which case + * `unpack.bytes_remaining` equals `buf.length`. Throws on malformed input or + * when a container/string/bin header exceeds the decoder's limits. + */ +export function unpack(buf: Buffer): any; + +export namespace unpack { + /** + * Bytes left in the buffer passed to the most recent `unpack()` call on + * this thread. Read it immediately after `unpack()`: the next call + * overwrites it. + */ + let bytes_remaining: number; +} + +/** + * Frames MessagePack messages over a stream. + * + * Emits `'msg'` with each decoded value, and `'error'` if a packet cannot be + * decoded (the buffered data is then dropped). + */ +export class Stream extends EventEmitter { + constructor(s: NodeJS.ReadWriteStream); + + /** Buffered bytes not yet forming a complete message, or `null`. */ + buf: Buffer | null; + + /** + * Pack `m` and write it to the underlying stream. Extra arguments are + * forwarded to `stream.write()` (encoding, callback). + */ + send(m: any, ...args: any[]): boolean; +} diff --git a/lib/msgpack.js b/lib/msgpack.js index 67c8d9e..cd8a259 100644 --- a/lib/msgpack.js +++ b/lib/msgpack.js @@ -1,91 +1,88 @@ -// Wrap a nicer JavaScript API that wraps the direct MessagePack bindings. +// Wrap a nicer JavaScript API around the MessagePack native bindings. -var buffer = require('buffer'); -var events = require('events'); -var mpBindings; -mpBindings = require(__dirname + "/../build/Release/msgpackBinding"); +'use strict'; -var sys; -try { - sys = require('util'); -} catch (e) { - sys = require('sys'); -} +const buffer = require('buffer'); +const events = require('events'); +const util = require('util'); -var bpack = mpBindings.pack; -var unpack = mpBindings.unpack; +const mpBindings = require(__dirname + '/../build/Release/msgpackBinding'); -exports.pack = pack; -exports.unpack = unpack; +const bpack = mpBindings.pack; +const rawUnpack = mpBindings.unpack; +/* No JS pre-pass: the binding already applies toJSON at every level and + * packs Dates as ISO strings. Calling toJSON here instead turned a top-level + * Buffer into Buffer.prototype.toJSON's {type,data} map rather than bin. */ function pack() { - var args = arguments, that, i; - for (i = 0; i < arguments.length; i++) { - that = args[i]; - if (that && typeof that === 'object' && - typeof that.toJSON === 'function') { - args[i] = that.toJSON(); - } - } - return bpack.apply(null, args); + return bpack.apply(null, arguments); } -var Stream = function(s) { - var self = this; - - events.EventEmitter.call(self); - - // Buffer of incomplete stream data - self.buf = null; +function unpack(buf) { + const result = rawUnpack(buf); + unpack.bytes_remaining = mpBindings.bytesRemaining(); + return result; +} - // Send a message down the stream - // - // Allows the caller to pass additional arguments, which are passed - // faithfully down to the write() method of the underlying stream. - self.send = function(m) { - // Sigh, no arguments.slice() method - var args = [pack(m)]; - for (i = 1; i < arguments.length; i++) { - args.push(arguments[i]); - } +unpack.bytes_remaining = 0; - return s.write.apply(s, args); - }; +function Stream(s) { + const self = this; + events.EventEmitter.call(self); + self.buf = null; - // Listen for data from the underlying stream, consuming it and emitting - // 'msg' events as we find whole messages. - s.addListener('data', function(d) { - // Make sure that self.buf reflects the entirety of the unread stream - // of bytes; it needs to be a single buffer - if (self.buf) { - var b = new buffer.Buffer(self.buf.length + d.length); - self.buf.copy(b, 0, 0, self.buf.length); - d.copy(b, self.buf.length, 0, d.length); + self.send = function (m) { + const args = [pack(m)]; + for (let i = 1; i < arguments.length; i++) { + args.push(arguments[i]); + } + return s.write.apply(s, args); + }; - self.buf = b; - } else { - self.buf = d; - } + s.addListener('data', function (d) { + if (self.buf) { + const b = buffer.Buffer.allocUnsafe(self.buf.length + d.length); + self.buf.copy(b, 0, 0, self.buf.length); + d.copy(b, self.buf.length, 0, d.length); + self.buf = b; + } else { + self.buf = d; + } - // Consume messages from the stream, one by one - while (self.buf && self.buf.length > 0) { - var msg = unpack(self.buf); - if (!msg) { - break; - } + while (self.buf && self.buf.length > 0) { + let msg; + try { + msg = unpack(self.buf); + } catch (err) { + /* A malformed or oversized packet is unrecoverable for this stream: + * drop the buffer rather than re-parsing the same bomb forever. */ + self.buf = null; + self.emit('error', err); + return; + } + /* bytes_remaining is a single native global, overwritten by the next + * unpack() anywhere in the process. Snapshot it before anything else + * can run, so a 'msg' listener that unpacks cannot desync this loop. */ + const remaining = unpack.bytes_remaining; + /* null means "incomplete" only when nothing was consumed; a decoded + * nil (0xc0) is a real message and must be emitted. */ + if (msg === null && remaining === self.buf.length) { + break; + } + /* Consume the frame before emitting: a listener that throws must not + * leave its own bytes queued for a later data event to re-deliver. */ + if (remaining > 0) { + self.buf = self.buf.slice(self.buf.length - remaining); + } else { + self.buf = null; + } + self.emit('msg', msg); + } + }); +} - self.emit('msg', msg); - if (unpack.bytes_remaining > 0) { - self.buf = self.buf.slice( - self.buf.length - unpack.bytes_remaining, - self.buf.length - ); - } else { - self.buf = null; - } - } - }); -}; +util.inherits(Stream, events.EventEmitter); -sys.inherits(Stream, events.EventEmitter); +exports.pack = pack; +exports.unpack = unpack; exports.Stream = Stream; diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..6bac0d7 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,755 @@ +{ + "name": "msgpack", + "version": "2.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "msgpack", + "version": "2.0.0", + "license": "BSD-3-Clause", + "dependencies": { + "nan": "^2.23.1" + }, + "bin": { + "json2msgpack": "bin/json2msgpack", + "msgpack2json": "bin/msgpack2json" + }, + "devDependencies": { + "c8": "^12.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@bcoe/v8-coverage": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz", + "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/@istanbuljs/schema": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.6.tgz", + "integrity": "sha512-+Sg6GCR/wy1oSmQDFq4LQDAhm3ETKnorxN+y5nbLULOR3P0c14f2Wurzj3/xqPXtasLFfHd5iRFQ7AJt4KH2cw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", + "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@types/istanbul-lib-coverage": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz", + "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==", + "dev": true, + "license": "MIT" + }, + "node_modules/ansi-regex": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.3.0.tgz", + "integrity": "sha512-WpDfL7NO6j7tH88IDBNVdUJxDh9nmCteAVW9dsep846XdwF4naCBK+/tGLX3KJgcpgMRXCFlTM2hKGoK9FsdrQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/ansi-styles": { + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/brace-expansion": { + "version": "5.0.9", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz", + "integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/c8": { + "version": "12.0.0", + "resolved": "https://registry.npmjs.org/c8/-/c8-12.0.0.tgz", + "integrity": "sha512-4zpJvrd1nKWutnnKC2pXkFmb6iM1l+ffN//o1CzlTNwW7GSOs9a1xrLqkC48nU8oEkjmPZLPiwMsIaOvoF4Pqg==", + "dev": true, + "license": "ISC", + "dependencies": { + "@bcoe/v8-coverage": "^1.0.1", + "@istanbuljs/schema": "^0.1.3", + "find-up": "^5.0.0", + "foreground-child": "^3.1.1", + "istanbul-lib-coverage": "^3.2.0", + "istanbul-lib-report": "^3.0.1", + "istanbul-reports": "^3.1.6", + "test-exclude": "^8.0.0", + "v8-to-istanbul": "^9.0.0", + "yargs": "^18.0.0", + "yargs-parser": "^21.1.1" + }, + "bin": { + "c8": "bin/c8.js" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=23" + }, + "peerDependencies": { + "monocart-coverage-reports": "^2" + }, + "peerDependenciesMeta": { + "monocart-coverage-reports": { + "optional": true + } + } + }, + "node_modules/cliui": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-9.0.1.tgz", + "integrity": "sha512-k7ndgKhwoQveBL+/1tqGJYNz097I7WOvwbmmU2AR5+magtbjPWQTS1C5vzGkBC8Ym8UWRzfKUzUUqFLypY4Q+w==", + "dev": true, + "license": "ISC", + "dependencies": { + "string-width": "^7.2.0", + "strip-ansi": "^7.1.0", + "wrap-ansi": "^9.0.0" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/cliui/node_modules/string-width": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz", + "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^10.3.0", + "get-east-asian-width": "^1.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/emoji-regex": { + "version": "10.6.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.6.0.tgz", + "integrity": "sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==", + "dev": true, + "license": "MIT" + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/foreground-child": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", + "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "dev": true, + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.6", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true, + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-east-asian-width": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.6.0.tgz", + "integrity": "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/glob": { + "version": "13.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", + "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.2.2", + "minipass": "^7.1.3", + "path-scurry": "^2.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "dev": true, + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", + "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", + "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^4.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-reports": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz", + "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lru-cache": { + "version": "11.5.2", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.2.tgz", + "integrity": "sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/make-dir": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", + "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/minimatch": { + "version": "10.2.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz", + "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.8" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/nan": { + "version": "2.28.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.28.0.tgz", + "integrity": "sha512-fTsDz99OTq2sVePhGdp4qQhggZFtKr64ZNVyVajRKtMOkJxYekplBh577PiJB12v/D3s2E5cGtOI45LWp6rnLQ==", + "license": "MIT" + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/semver": { + "version": "7.8.5", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz", + "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/string-width": { + "version": "8.2.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-8.2.2.tgz", + "integrity": "sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg==", + "dev": true, + "license": "MIT", + "dependencies": { + "get-east-asian-width": "^1.5.0", + "strip-ansi": "^7.1.2" + }, + "engines": { + "node": ">=20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/strip-ansi": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz", + "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.2.2" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/test-exclude": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-8.0.0.tgz", + "integrity": "sha512-ZOffsNrXYggvU1mDGHk54I96r26P8SyMjO5slMKSc7+IWmtB/MQKnEC2fP51imB3/pT6YK5cT5E8f+Dd9KdyOQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^13.0.6", + "minimatch": "^10.2.2" + }, + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/v8-to-istanbul": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.3.0.tgz", + "integrity": "sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==", + "dev": true, + "license": "ISC", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.12", + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^2.0.0" + }, + "engines": { + "node": ">=10.12.0" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/wrap-ansi": { + "version": "9.0.2", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.2.tgz", + "integrity": "sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.2.1", + "string-width": "^7.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/string-width": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz", + "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^10.3.0", + "get-east-asian-width": "^1.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs": { + "version": "18.1.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-18.1.0.tgz", + "integrity": "sha512-2rAgRKu54VsHkqI0/tYkmluGXHD4KW7yZoycuqDQ15QOTnc2VVfy0nN/1eMhnQLO00A+dwtK20xuCnc1YGeUyg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cliui": "^9.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "string-width": "^8.2.1", + "y18n": "^5.0.5", + "yargs-parser": "^22.0.0" + }, + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=23" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs/node_modules/yargs-parser": { + "version": "22.0.0", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-22.0.0.tgz", + "integrity": "sha512-rwu/ClNdSMpkSrUb+d6BRsSkLUq1fmfsY6TOpYzTwvwkg1/NRG85KBy3kq++A8LKQwX6lsu+aWad+2khvuXrqw==", + "dev": true, + "license": "ISC", + "engines": { + "node": "^20.19.0 || ^22.12.0 || >=23" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/package.json b/package.json index 4f10e6f..35adbc6 100644 --- a/package.json +++ b/package.json @@ -1,83 +1,40 @@ { - "name": "msgpack", - "description": "A space-efficient object serialization library for node.js", - "version": "1.0.3", - "homepage": "https://github.com/msgpack/msgpack-node", - "contributors": [ - { - "name": "Amos Barreto", - "url": "https://github.com/squamos" - }, - { - "name": "Peter Griess", - "url": "https://github.com/pgriess", - "email": "pg@std.in" - }, - { - "name": "Maxwell Krohn", - "url": "https://github.com/maxtaco" - }, - { - "name": "Jaye Marshall", - "url": "https://github.com/jmars" - }, - { - "name": "matthiasg", - "url": "https://github.com/matthiasg" - }, - { - "name": "Christopher Mooney", - "url": "https://github.com/godsflaw", - "email": "chris@dod.net" - }, - { - "name": "Michael Phan-Ba", - "url": "https://github.com/mikepb" - }, - { - "name": "Bob Potter", - "url": "https://github.com/bpot" - }, - { - "name": "rashfael", - "url": "https://github.com/rashfael" - }, - { - "name": "Tom Taylor", - "email": "tom@tomtaylor.co.uk", - "url": "https://github.com/tomtaylor" - }, - { - "name": "Brian White", - "url": "https://github.com/mscdex" - }, - { - "name": "Keiji Yoshimi", - "url": "https://github.com/walf443" - } - ], - "repository": { - "type": "git", - "url": "https://github.com/msgpack/msgpack-node.git" - }, - "main": "./lib/msgpack", - "directories": { - "lib": "lib" - }, - "dependencies": { - "nan": "^2.14.0" - }, - "devDependencies": { - "nodeunit": "https://github.com/godsflaw/nodeunit/archive/master.tar.gz" - }, - "engines": { - "node": ">=0.12.7" - }, - "bin": { - "json2msgpack": "./bin/json2msgpack", - "msgpack2json": "./bin/msgpack2json" - }, - "scripts": { - "test": "./run_tests" - } + "name": "msgpack", + "description": "A space-efficient object serialization library for Node.js", + "version": "2.0.0", + "homepage": "https://github.com/msgpack/msgpack-node", + "author": "Peter Griess ", + "contributors": [], + "repository": { + "type": "git", + "url": "https://github.com/msgpack/msgpack-node.git" + }, + "main": "./lib/msgpack", + "types": "index.d.ts", + "directories": { + "lib": "lib" + }, + "engines": { + "node": ">=18" + }, + "dependencies": { + "nan": "^2.23.1" + }, + "scripts": { + "test": "node --test test/*.test.js", + "bench": "node test/benchmark/benchmark.js", + "rebuild": "node-gyp rebuild", + "coverage": "npm run coverage:js && npm run coverage:native", + "coverage:js": "c8 --include=lib --include=bin --extension=.js --extension= --all --check-coverage --statements 95 --branches 95 --functions 95 --lines 95 --reporter=text --reporter=lcov node --test test/*.test.js", + "coverage:native": "node scripts/coverage-native.js" + }, + "bin": { + "json2msgpack": "./bin/json2msgpack", + "msgpack2json": "./bin/msgpack2json" + }, + "gypfile": true, + "license": "BSD-3-Clause", + "devDependencies": { + "c8": "^12.0.0" + } } diff --git a/run_tests b/run_tests index a3b1a2d..da1e5ce 100755 --- a/run_tests +++ b/run_tests @@ -1,27 +1,3 @@ -#!/usr/bin/env node - -"use strict"; - -try { - var reporter = require('nodeunit').reporters.default; -} -catch(e) { - console.log("Error: " + e.message); - console.log(""); - console.log("Cannot find required modules."); - console.log("You can intall modules for this project by doing:"); - console.log(""); - console.log(" npm install"); - console.log(""); - process.exit(); -} - -process.chdir(__dirname); - -if (process.argv[2]) { - reporter.run(process.argv.slice(2, process.argv.length)); -} else { - reporter.run(['test', 'test/lib'], undefined, function () { - process.exit(); - }); -} +#!/bin/sh +# Compatibility wrapper. Tests now use node:test. +exec npm test "$@" diff --git a/scripts/coverage-native.js b/scripts/coverage-native.js new file mode 100644 index 0000000..7883a3c --- /dev/null +++ b/scripts/coverage-native.js @@ -0,0 +1,140 @@ +#!/usr/bin/env node +// Native (C++) coverage for src/msgpack.cc. +// +// Rebuilds the addon with --coverage, runs the test suite against that +// instrumented binary, reports with gcovr, and then *always* rebuilds without +// the coverage variable so the working tree is left with a normal addon -- +// even when the thresholds fail. The exit code is the gcovr/test result. + +'use strict'; + +const fs = require('fs'); +const path = require('path'); +const { spawnSync } = require('child_process'); + +const ROOT = path.join(__dirname, '..'); +const LINE_THRESHOLD = 95; +const BRANCH_THRESHOLD = 95; + +function run(cmd, args, opts) { + const label = [cmd].concat(args).join(' '); + console.log('\n$ ' + label); + const r = spawnSync(cmd, args, Object.assign({ cwd: ROOT, stdio: 'inherit' }, opts)); + if (r.error && r.error.code === 'ENOENT') { + return { status: 127, missing: true }; + } + return { status: r.status === null ? 1 : r.status, missing: false }; +} + +// npm puts its bundled node-gyp on PATH for lifecycle scripts, but this file +// is also runnable directly (`node scripts/coverage-native.js`), so fall back +// to a local install and then to npx. +const nodeGyp = process.platform === 'win32' ? 'node-gyp.cmd' : 'node-gyp'; +const localGyp = path.join(ROOT, 'node_modules', '.bin', nodeGyp); + +function rebuild(withCoverage) { + const args = ['rebuild']; + if (withCoverage) args.push('--msgpack_coverage=1'); + + if (fs.existsSync(localGyp)) return run(localGyp, args); + const direct = run(nodeGyp, args); + if (!direct.missing) return direct; + return run(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['node-gyp'].concat(args)); +} + +function removeCounters() { + // Stale .gcda from an earlier run would be merged into this one. + const stack = [path.join(ROOT, 'build')]; + while (stack.length) { + const dir = stack.pop(); + let entries; + try { + entries = fs.readdirSync(dir, { withFileTypes: true }); + } catch (err) { + if (err.code === 'ENOENT') continue; + throw err; + } + for (const e of entries) { + const p = path.join(dir, e.name); + if (e.isDirectory()) stack.push(p); + else if (e.name.endsWith('.gcda')) fs.unlinkSync(p); + } + } +} + +function testFiles() { + return fs + .readdirSync(path.join(ROOT, 'test')) + .filter((f) => f.endsWith('.test.js')) + .sort() + .map((f) => path.join('test', f)); +} + +// gcov shipped with Xcode is a stub; clang builds need `llvm-cov gcov`. +function gcovExecutable() { + if (process.env.GCOV) return process.env.GCOV; + if (process.platform === 'darwin') return 'llvm-cov gcov'; + return 'gcov'; +} + +function main() { + let status = rebuild(true).status; + if (status !== 0) { + console.error('coverage:native: instrumented build failed'); + return status; + } + + removeCounters(); + + status = run(process.execPath, ['--test'].concat(testFiles())).status; + if (status !== 0) { + console.error('coverage:native: test suite failed under the instrumented addon'); + return status; + } + + const gcovr = run('gcovr', [ + '--root', '.', + '--filter', 'src/', + '--exclude', 'deps/', + '--gcov-executable', gcovExecutable(), + // C++ EH edges and provably dead branches are not test gaps; see + // COVERAGE.md for the full list of what these two flags drop. + '--exclude-throw-branches', + '--exclude-unreachable-branches', + '--txt-metric', 'branch', + '--txt', '-', + '--txt-summary', + '--fail-under-line', String(LINE_THRESHOLD), + '--fail-under-branch', String(BRANCH_THRESHOLD), + ]); + + if (gcovr.missing) { + console.error( + 'coverage:native: gcovr not found. Install it with `pip install gcovr`.' + ); + return 127; + } + if (gcovr.status !== 0) { + console.error( + 'coverage:native: below the ' + + LINE_THRESHOLD + + '% line / ' + + BRANCH_THRESHOLD + + '% branch threshold' + ); + } + return gcovr.status; +} + +let result = 1; +try { + result = main(); +} finally { + // Leave the tree with an ordinary, uninstrumented addon whatever happened. + const clean = rebuild(false); + if (clean.status !== 0) { + console.error('coverage:native: failed to restore the uninstrumented build'); + result = result || clean.status; + } +} +process.exit(result); diff --git a/src/msgpack.cc b/src/msgpack.cc index 90883eb..c8a23e6 100644 --- a/src/msgpack.cc +++ b/src/msgpack.cc @@ -1,352 +1,837 @@ -#include -#include -#include -#include +/* + * Node.js MessagePack bindings. + * + * Pack/unpack JavaScript values via vendored msgpack-c (C API). + * Unpack is fail-closed: oversized array/map/string/bin headers are rejected + * before the C library allocates. Pack errors always release the sbuffer + * (nodejs/node#25686). + * + * GCOVR_EXCL_BR_LINE / _START / _STOP markers below mark branches that cannot + * be reached from JS without stubbing the allocator or V8: allocation-failure + * arms of msgpack_pack_*, empty-MaybeLocal guards V8 only produces while an + * exception is pending, and post-ScanOne error arms that ScanOne has already + * ruled out. Each carries the reason inline; COVERAGE.md lists them all. + */ + #include -#include -#include -#include -#include -#include +#include -using namespace std; -using namespace v8; -using namespace node; +#include +#include -#define SBUF_POOL 50000 +namespace { + +const uint32_t kMaxContainer = 1000000u; +const uint32_t kMaxBytes = 32u * 1024u * 1024u; +const int kMaxDepth = 512; +/* Pack recursion is bounded the same way master bounded it, so deeply nested + * input throws instead of running the C stack out. */ +const int kMaxPackDepth = 512; +/* Largest/smallest doubles that survive a cast to uint64_t/int64_t. */ +const double kTwoPow64 = 18446744073709551616.0; +const double kInt64Min = -9223372036854775808.0; +const size_t kSbufferPoolMax = 512; + +enum ScanStatus { + kScanOk = 0, + kScanContinue, + kScanLimit, + kScanParse +}; -// MSC does not support C99 trunc function. -#ifdef _MSC_BUILD -double trunc(double d){ return (d>0) ? floor(d) : ceil(d) ; } -#endif +struct Cursor { + const unsigned char* p; + const unsigned char* end; +}; +static bool ReadU8(Cursor* c, uint8_t* out) { + if (c->p >= c->end) return false; + *out = *c->p++; + return true; +} -static Nan::Persistent msgpack_unpack_template; +static bool ReadU16(Cursor* c, uint16_t* out) { + if (c->end - c->p < 2) return false; + *out = static_cast((c->p[0] << 8) | c->p[1]); + c->p += 2; + return true; +} +static bool ReadU32(Cursor* c, uint32_t* out) { + if (c->end - c->p < 4) return false; + *out = (static_cast(c->p[0]) << 24) | + (static_cast(c->p[1]) << 16) | + (static_cast(c->p[2]) << 8) | + static_cast(c->p[3]); + c->p += 4; + return true; +} -// An exception class that wraps a textual message -class MsgpackException { - public: - MsgpackException(const char *str) : - msg(Nan::New(str).ToLocalChecked()) { - } +static bool Skip(Cursor* c, size_t n) { + if (static_cast(c->end - c->p) < n) return false; + c->p += n; + return true; +} - Local getThrownException() { - return Nan::TypeError(msg); - } +static ScanStatus CheckContainer(uint32_t n, size_t remaining, bool is_map, int sp) { + if (n > kMaxContainer) return kScanLimit; + uint64_t items = is_map ? static_cast(n) * 2u : n; + if (items > remaining) { + /* Declared payload cannot exist in this buffer. If n is huge this is + * a DoS header; if n is modest the message is merely truncated. */ + /* Both disjuncts are already excluded above: n > kMaxContainer returned + * at the top, and items is at most 2 * kMaxContainer, far under + * kMaxBytes. Kept as defence in depth if either constant changes. */ + if (n > kMaxContainer || items > kMaxBytes) return kScanLimit; /* GCOVR_EXCL_BR_LINE */ + return kScanContinue; + } + if (sp >= kMaxDepth) return kScanLimit; + return kScanOk; +} - private: - const Local msg; -}; +static ScanStatus CheckBytes(uint32_t n, size_t remaining) { + if (n > kMaxBytes) return kScanLimit; + if (n > remaining) return kScanContinue; + return kScanOk; +} -// A holder for a msgpack_zone object; ensures destruction on scope exit -class MsgpackZone { - public: - msgpack_zone _mz; +/* + * Walk one MessagePack object. Extra trailing bytes are allowed (streaming). + * Incomplete headers/payloads return kScanContinue. Absurd sizes return + * kScanLimit without allocating. + */ +static ScanStatus ScanOne(const char* data, size_t len, size_t* consumed) { + Cursor c; + c.p = reinterpret_cast(data); + c.end = c.p + len; + + struct Frame { uint32_t remaining; }; + Frame stack[kMaxDepth]; + int sp = 0; + stack[sp++].remaining = 1; + + while (sp > 0) { + if (stack[sp - 1].remaining == 0) { + sp--; + continue; + } + stack[sp - 1].remaining--; - MsgpackZone(size_t sz = 1024) { - msgpack_zone_init(&this->_mz, sz); - } + uint8_t b; + if (!ReadU8(&c, &b)) return kScanContinue; - ~MsgpackZone() { - msgpack_zone_destroy(&this->_mz); - } -}; + if (b <= 0x7f || b >= 0xe0) { + continue; /* fixint */ + } + if ((b & 0xf0) == 0x80) { /* fixmap */ + uint32_t n = b & 0x0f; + ScanStatus st = CheckContainer(n, static_cast(c.end - c.p), true, sp); + if (st != kScanOk) return st; + stack[sp++].remaining = n * 2u; + continue; + } + if ((b & 0xf0) == 0x90) { /* fixarray */ + uint32_t n = b & 0x0f; + ScanStatus st = CheckContainer(n, static_cast(c.end - c.p), false, sp); + if (st != kScanOk) return st; + stack[sp++].remaining = n; + continue; + } + if ((b & 0xe0) == 0xa0) { /* fixstr */ + uint32_t n = b & 0x1f; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + continue; + } -static stack sbuffers; - -#define DBG_PRINT_BUF(buf, name) \ - do { \ - fprintf(stderr, "Buffer %s has %lu bytes:\n", \ - (name), Buffer::Length(buf) \ - ); \ - for (uint32_t i = 0; i * 16 < Buffer::Length(buf); i++) { \ - fprintf(stderr, " "); \ - for (uint32_t ii = 0; \ - ii < 16 && (i * 16) + ii < Buffer::Length(buf); \ - ii++) { \ - fprintf(stderr, "%s%2.2hhx", \ - (ii > 0 && (ii % 2 == 0)) ? " " : "", \ - Buffer::Data(buf)[i * 16 + ii] \ - ); \ - } \ - fprintf(stderr, "\n"); \ - } \ - } while (0) - -// This will be passed to Buffer::New so that we can manage our own memory. -// In other news, I am unsure what to do with hint, as I've never seen this -// coding pattern before. For now I have overloaded it to be a void pointer -// to a msgpack_sbuffer. This let's us push it onto the stack for use later. -static void -_free_sbuf(char *data, void *hint) { - if (data != NULL && hint != NULL) { - msgpack_sbuffer *sbuffer = (msgpack_sbuffer *)hint; - if (sbuffers.size() > SBUF_POOL || - sbuffer->alloc > (MSGPACK_SBUFFER_INIT_SIZE * 5)) { - msgpack_sbuffer_free(sbuffer); - } else { - sbuffer->size = 0; - sbuffers.push(sbuffer); - } + switch (b) { + case 0xc0: /* nil */ + case 0xc2: /* false */ + case 0xc3: /* true */ + break; + case 0xc1: + return kScanParse; + case 0xc4: { /* bin8 */ + uint8_t n; + if (!ReadU8(&c, &n)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xc5: { /* bin16 */ + uint16_t n; + if (!ReadU16(&c, &n)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xc6: { /* bin32 */ + uint32_t n; + if (!ReadU32(&c, &n)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xc7: { /* ext8 */ + uint8_t n; + if (!ReadU8(&c, &n)) return kScanContinue; + if (!Skip(&c, 1)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xc8: { /* ext16 */ + uint16_t n; + if (!ReadU16(&c, &n)) return kScanContinue; + if (!Skip(&c, 1)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xc9: { /* ext32 */ + uint32_t n; + if (!ReadU32(&c, &n)) return kScanContinue; + if (!Skip(&c, 1)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xca: /* float32 */ + if (!Skip(&c, 4)) return kScanContinue; + break; + case 0xcb: /* float64 */ + if (!Skip(&c, 8)) return kScanContinue; + break; + case 0xcc: /* uint8 */ + if (!Skip(&c, 1)) return kScanContinue; + break; + case 0xcd: /* uint16 */ + if (!Skip(&c, 2)) return kScanContinue; + break; + case 0xce: /* uint32 */ + if (!Skip(&c, 4)) return kScanContinue; + break; + case 0xcf: /* uint64 */ + if (!Skip(&c, 8)) return kScanContinue; + break; + case 0xd0: /* int8 */ + if (!Skip(&c, 1)) return kScanContinue; + break; + case 0xd1: /* int16 */ + if (!Skip(&c, 2)) return kScanContinue; + break; + case 0xd2: /* int32 */ + if (!Skip(&c, 4)) return kScanContinue; + break; + case 0xd3: /* int64 */ + if (!Skip(&c, 8)) return kScanContinue; + break; + case 0xd4: /* fixext1 */ + if (!Skip(&c, 2)) return kScanContinue; + break; + case 0xd5: /* fixext2 */ + if (!Skip(&c, 3)) return kScanContinue; + break; + case 0xd6: /* fixext4 */ + if (!Skip(&c, 5)) return kScanContinue; + break; + case 0xd7: /* fixext8 */ + if (!Skip(&c, 9)) return kScanContinue; + break; + case 0xd8: /* fixext16 */ + if (!Skip(&c, 17)) return kScanContinue; + break; + case 0xd9: { /* str8 */ + uint8_t n; + if (!ReadU8(&c, &n)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xda: { /* str16 */ + uint16_t n; + if (!ReadU16(&c, &n)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xdb: { /* str32 */ + uint32_t n; + if (!ReadU32(&c, &n)) return kScanContinue; + ScanStatus st = CheckBytes(n, static_cast(c.end - c.p)); + if (st != kScanOk) return st; + if (!Skip(&c, n)) return kScanContinue; /* GCOVR_EXCL_BR_LINE: CheckBytes proved n <= remaining */ + break; + } + case 0xdc: { /* array16 */ + uint16_t n; + if (!ReadU16(&c, &n)) return kScanContinue; + ScanStatus st = CheckContainer(n, static_cast(c.end - c.p), false, sp); + if (st != kScanOk) return st; + stack[sp++].remaining = n; + break; + } + case 0xdd: { /* array32 */ + uint32_t n; + if (!ReadU32(&c, &n)) return kScanContinue; + ScanStatus st = CheckContainer(n, static_cast(c.end - c.p), false, sp); + if (st != kScanOk) return st; + stack[sp++].remaining = n; + break; + } + case 0xde: { /* map16 */ + uint16_t n; + if (!ReadU16(&c, &n)) return kScanContinue; + ScanStatus st = CheckContainer(n, static_cast(c.end - c.p), true, sp); + if (st != kScanOk) return st; + stack[sp++].remaining = static_cast(n) * 2u; + break; + } + case 0xdf: { /* map32 */ + uint32_t n; + if (!ReadU32(&c, &n)) return kScanContinue; + ScanStatus st = CheckContainer(n, static_cast(c.end - c.p), true, sp); + if (st != kScanOk) return st; + stack[sp++].remaining = n * 2u; + break; + } + default: + return kScanParse; } + } + + *consumed = static_cast(c.p - reinterpret_cast(data)); + return kScanOk; } -// Convert a V8 object to a MessagePack object. -// -// This method is recursive. It will probably blow out the stack on objects -// with extremely deep nesting. -// -// If a circular reference is detected, an exception is thrown. -static void -v8_to_msgpack(Local v8obj, msgpack_object *mo, msgpack_zone *mz, size_t depth) { - if (512 < ++depth) { - throw MsgpackException("Cowardly refusing to pack object with circular reference"); - } +class MsgpackException { + public: + explicit MsgpackException(v8::Local err) : err_(err) {} + v8::Local value() const { return err_; } - if (v8obj->IsUndefined() || v8obj->IsNull()) { - mo->type = MSGPACK_OBJECT_NIL; - } else if (v8obj->IsBoolean()) { - mo->type = MSGPACK_OBJECT_BOOLEAN; - mo->via.boolean = Nan::To(v8obj).FromJust(); - } else if (v8obj->IsNumber()) { - double d = Nan::To(v8obj).FromJust(); - if (trunc(d) != d) { - mo->type = MSGPACK_OBJECT_FLOAT; - mo->via.f64 = d; - } else if (d > 0) { - mo->type = MSGPACK_OBJECT_POSITIVE_INTEGER; - mo->via.u64 = static_cast(d); - } else { - mo->type = MSGPACK_OBJECT_NEGATIVE_INTEGER; - mo->via.i64 = static_cast(d); - } - } else if (v8obj->IsString()) { - mo->type = MSGPACK_OBJECT_STR; - mo->via.str.size = static_cast(Nan::DecodeBytes(v8obj, Nan::Encoding::UTF8)); - mo->via.str.ptr = (char*) msgpack_zone_malloc(mz, mo->via.str.size); - - Nan::DecodeWrite((char*)mo->via.str.ptr, mo->via.str.size, v8obj, Nan::Encoding::UTF8); - } else if (v8obj->IsDate()) { - mo->type = MSGPACK_OBJECT_STR; - Local date = Local::Cast(v8obj); - Local func = Local::Cast(Nan::Get(date, Nan::New("toISOString").ToLocalChecked()).ToLocalChecked()); - Local argv[1] = {}; - Local result = Nan::Call(func, date, 0, argv).ToLocalChecked(); - mo->via.str.size = static_cast(Nan::DecodeBytes(result, Nan::Encoding::UTF8)); - mo->via.str.ptr = (char*) msgpack_zone_malloc(mz, mo->via.str.size); - - Nan::DecodeWrite((char*)mo->via.str.ptr, mo->via.str.size, result, Nan::Encoding::UTF8); - } else if (v8obj->IsArray()) { - Local o = Nan::To(v8obj).ToLocalChecked(); - Local a = Local::Cast(o); - - mo->type = MSGPACK_OBJECT_ARRAY; - mo->via.array.size = a->Length(); - mo->via.array.ptr = (msgpack_object*) msgpack_zone_malloc( - mz, - sizeof(msgpack_object) * mo->via.array.size - ); - - for (uint32_t i = 0; i < a->Length(); i++) { - Local v = Nan::Get(a, i).ToLocalChecked(); - v8_to_msgpack(v, &mo->via.array.ptr[i], mz, depth); - } - } else if (Buffer::HasInstance(v8obj)) { - Local buf = Nan::To(v8obj).ToLocalChecked(); + private: + v8::Local err_; +}; - mo->type = MSGPACK_OBJECT_BIN; - mo->via.bin.size = static_cast(Buffer::Length(buf)); - mo->via.bin.ptr = Buffer::Data(buf); - } else { - Local o = Nan::To(v8obj).ToLocalChecked(); - Local toJSON = Nan::New("toJSON").ToLocalChecked(); - // for o.toJSON() - if (Nan::Has(o, toJSON).FromJust() && Nan::Get(o, toJSON).ToLocalChecked()->IsFunction()) { - Local fn = Local::Cast(Nan::Get(o, toJSON).ToLocalChecked()); - v8_to_msgpack(Nan::Call(fn, o, 0, NULL).ToLocalChecked(), mo, mz, depth); - return; - } +static v8::Local Error(const char* msg) { + return Nan::Error(msg); +} - Local a = Nan::GetPropertyNames(o).ToLocalChecked(); +/* Persistent identity flag for cycle detection (not enumerable). + * thread_local because a v8::Persistent belongs to the isolate that created + * it: with a process-global handle, a worker's Init() would dispose the main + * isolate's string and then hand its own back to main-thread pack(). */ +static thread_local Nan::Persistent stack_key; - mo->type = MSGPACK_OBJECT_MAP; - mo->via.map.size = a->Length(); - mo->via.map.ptr = (msgpack_object_kv*) msgpack_zone_malloc( - mz, - sizeof(msgpack_object_kv) * mo->via.map.size - ); +static v8::Local StackKey() { + return Nan::New(stack_key); +} - for (uint32_t i = 0; i < a->Length(); i++) { - Local k = Nan::Get(a, i).ToLocalChecked(); +static void Mark(v8::Local obj) { + Nan::SetPrivate(obj, StackKey(), Nan::True()); +} - v8_to_msgpack(k, &mo->via.map.ptr[i].key, mz, depth); - v8_to_msgpack(Nan::Get(o, k).ToLocalChecked(), &mo->via.map.ptr[i].val, mz, depth); - } - } +static void Unmark(v8::Local obj) { + Nan::DeletePrivate(obj, StackKey()); } -// Convert a MessagePack object to a V8 object. -// -// This method is recursive. It will probably blow out the stack on objects -// with extremely deep nesting. -static Local -msgpack_to_v8(msgpack_object *mo) { - switch (mo->type) { - case MSGPACK_OBJECT_NIL: - return Nan::Null(); +static bool IsMarked(v8::Local obj) { + Nan::MaybeLocal v = Nan::GetPrivate(obj, StackKey()); + /* A private-symbol read runs no interceptor and no Proxy trap, so it + * cannot leave an exception pending and cannot come back empty. */ + if (v.IsEmpty()) return false; /* GCOVR_EXCL_BR_LINE */ + return v.ToLocalChecked()->IsTrue(); +} - case MSGPACK_OBJECT_BOOLEAN: - return (mo->via.boolean) ? - Nan::True() : - Nan::False(); +static void JsToMsgpack(msgpack_packer* pk, v8::Local o, int depth); + +/* + * Call a zero-argument JS method, converting a JS-level throw into a + * MsgpackException carrying the original error so Pack() can rethrow it. + */ +static v8::Local CallNoArgs(v8::Local recv, + v8::Local fn) { + Nan::TryCatch try_catch; + Nan::MaybeLocal r = Nan::Call(fn, recv, 0, NULL); + if (r.IsEmpty()) { + v8::Local ex = try_catch.Exception(); + /* GCOVR_EXCL_BR_START: an empty Maybe always carries a pending + * exception, so the empty-exception fallback is unreachable. */ + if (ex.IsEmpty()) { + throw MsgpackException(Error("Error serializing object")); + } + /* GCOVR_EXCL_BR_STOP */ + throw MsgpackException(ex); + } + return r.ToLocalChecked(); +} - case MSGPACK_OBJECT_POSITIVE_INTEGER: - // As per Issue #42, we need to use the base Number - // class as opposed to the subclass Integer, since - // only the former takes 64-bit inputs. Using the - // Integer subclass will truncate 64-bit values. - return Nan::New(static_cast(mo->via.u64)); +/* + * Property reads during packing can run arbitrary JS: an accessor, a Proxy + * "get"/"ownKeys" trap, or an interceptor. When that JS throws, V8 hands back + * an empty Maybe, and ToLocalChecked() on it aborts the process + * ("FATAL ERROR: v8::ToLocalChecked Empty MaybeLocal"). These wrappers turn + * the throw into a MsgpackException carrying the original error, exactly as + * CallNoArgs does for method calls. + */ +static void ThrowCaught(const Nan::TryCatch& try_catch) { + v8::Local ex = try_catch.Exception(); + /* GCOVR_EXCL_BR_START: see CallNoArgs -- unreachable fallback. */ + if (ex.IsEmpty()) { + throw MsgpackException(Error("Error serializing object")); + } + /* GCOVR_EXCL_BR_STOP */ + throw MsgpackException(ex); +} - case MSGPACK_OBJECT_NEGATIVE_INTEGER: - // See comment for MSGPACK_OBJECT_POSITIVE_INTEGER - return Nan::New(static_cast(mo->via.i64)); +static v8::Local CheckedGet(v8::Local obj, + v8::Local key) { + Nan::TryCatch try_catch; + Nan::MaybeLocal r = Nan::Get(obj, key); + if (r.IsEmpty()) { + ThrowCaught(try_catch); /* GCOVR_EXCL_BR_LINE: never returns */ + } + return r.ToLocalChecked(); +} - case MSGPACK_OBJECT_FLOAT: - return Nan::New(mo->via.f64); +static v8::Local CheckedGet(v8::Local obj, uint32_t index) { + Nan::TryCatch try_catch; + Nan::MaybeLocal r = Nan::Get(obj, index); + if (r.IsEmpty()) { + ThrowCaught(try_catch); /* GCOVR_EXCL_BR_LINE: never returns */ + } + return r.ToLocalChecked(); +} - case MSGPACK_OBJECT_ARRAY: { - Local a = Nan::New(mo->via.array.size); +static v8::Local CheckedOwnNames(v8::Local obj) { + Nan::TryCatch try_catch; + Nan::MaybeLocal r = Nan::GetOwnPropertyNames(obj); + if (r.IsEmpty()) { + ThrowCaught(try_catch); /* GCOVR_EXCL_BR_LINE: never returns */ + } + return r.ToLocalChecked(); +} - for (uint32_t i = 0; i < mo->via.array.size; i++) { - Nan::Set(a, i, msgpack_to_v8(&mo->via.array.ptr[i])); - } +static void PackArray(msgpack_packer* pk, v8::Local arr, int depth) { + if (IsMarked(arr)) { + throw MsgpackException(Error("Cowardly refusing to pack circular reference")); + } + Mark(arr); + uint32_t len = arr->Length(); + /* GCOVR_EXCL_BR_START: msgpack_sbuffer_write only fails on realloc + * failure, which no JS-reachable input can force. */ + if (msgpack_pack_array(pk, len)) { + Unmark(arr); + throw MsgpackException(Error("Error serializing object")); + } + /* GCOVR_EXCL_BR_STOP */ + try { + for (uint32_t i = 0; i < len; i++) { + JsToMsgpack(pk, CheckedGet(arr, i), depth); + } + } catch (...) { + Unmark(arr); + throw; + } + Unmark(arr); +} - return a; +static void PackObject(msgpack_packer* pk, v8::Local obj, int depth) { + if (IsMarked(obj)) { + throw MsgpackException(Error("Cowardly refusing to pack circular reference")); + } + Mark(obj); + + /* toJSON wins over the map encoding, at every level, matching both + * JSON.stringify and the top-level wrapper in lib/msgpack.js. */ + v8::Local to_json; + try { + to_json = CheckedGet(obj, Nan::New("toJSON").ToLocalChecked()); + } catch (...) { + Unmark(obj); + throw; + } + if (to_json->IsFunction()) { + try { + JsToMsgpack(pk, CallNoArgs(obj, to_json.As()), depth); + } catch (...) { + Unmark(obj); + throw; } + Unmark(obj); + return; + } + + /* Every own enumerable key is packed, numeric keys included; V8 hands back + * index keys as Numbers, which JsToMsgpack packs as integer map keys. */ + v8::Local names; + try { + names = CheckedOwnNames(obj); + } catch (...) { + Unmark(obj); + throw; + } + uint32_t len = names->Length(); + /* GCOVR_EXCL_BR_START: allocation failure only, as in PackArray. */ + if (msgpack_pack_map(pk, len)) { + Unmark(obj); + throw MsgpackException(Error("Error serializing object")); + } + /* GCOVR_EXCL_BR_STOP */ + try { + for (uint32_t i = 0; i < len; i++) { + v8::Local key = CheckedGet(names, i); + JsToMsgpack(pk, key, depth); + JsToMsgpack(pk, CheckedGet(obj, key), depth); + } + } catch (...) { + Unmark(obj); + throw; + } + Unmark(obj); +} - case MSGPACK_OBJECT_STR: - return Nan::New(mo->via.str.ptr, mo->via.str.size).ToLocalChecked(); +static void JsToMsgpack(msgpack_packer* pk, v8::Local o, int depth) { + int rc = 0; + + if (kMaxPackDepth < ++depth) { + throw MsgpackException( + Error("Cowardly refusing to pack object nested more than 512 levels deep")); + } + + if (o->IsUndefined() || o->IsNull()) { + rc = msgpack_pack_nil(pk); + } else if (o->IsBoolean()) { + rc = o->IsTrue() ? msgpack_pack_true(pk) : msgpack_pack_false(pk); + } else if (o->IsNumber()) { + double d = Nan::To(o).FromJust(); + /* Only take an integer path when the value actually fits the integer + * type; otherwise the cast is undefined behavior (1e30 became 2^64-1). */ + if (std::isfinite(d) && std::trunc(d) == d && d >= 0 && d < kTwoPow64) { + rc = msgpack_pack_uint64(pk, static_cast(d)); + } else if (std::isfinite(d) && std::trunc(d) == d && d < 0 && d >= kInt64Min) { + rc = msgpack_pack_int64(pk, static_cast(d)); + } else { + rc = msgpack_pack_double(pk, d); + } + } else if (o->IsString()) { + Nan::Utf8String bytes(o); + rc = msgpack_pack_str(pk, bytes.length()); + if (rc == 0) { /* GCOVR_EXCL_BR_LINE: rc != 0 needs an allocation failure */ + rc = msgpack_pack_str_body(pk, *bytes, bytes.length()); + } + } else if (o->IsDate()) { + /* Dates pack as their ISO-8601 string, as they did before 2.0.0. */ + v8::Local date = o.As(); + v8::Local fn = + CheckedGet(date, Nan::New("toISOString").ToLocalChecked()); + if (!fn->IsFunction()) { + throw MsgpackException(Error("cannot pack Date")); + } + v8::Local iso = CallNoArgs(date, fn.As()); + Nan::Utf8String bytes(iso); + rc = msgpack_pack_str(pk, bytes.length()); + if (rc == 0) { /* GCOVR_EXCL_BR_LINE: rc != 0 needs an allocation failure */ + rc = msgpack_pack_str_body(pk, *bytes, bytes.length()); + } + } else if (o->IsArray()) { + PackArray(pk, o.As(), depth); + return; + } else if (node::Buffer::HasInstance(o)) { + char* data = node::Buffer::Data(o.As()); + size_t len = node::Buffer::Length(o.As()); + rc = msgpack_pack_bin(pk, len); + if (rc == 0) { /* GCOVR_EXCL_BR_LINE: rc != 0 needs an allocation failure */ + rc = msgpack_pack_bin_body(pk, data, len); + } + } else if (o->IsFunction()) { + throw MsgpackException(Error("cannot pack function")); + } else if (o->IsObject()) { + PackObject(pk, o.As(), depth); + return; + } else { + throw MsgpackException(Error("cannot pack object")); + } + + /* GCOVR_EXCL_BR_START: every rc above comes from an sbuffer write. */ + if (rc) { + throw MsgpackException(Error("Error serializing object")); + } + /* GCOVR_EXCL_BR_STOP */ +} + +static v8::Local MsgpackToJs(const msgpack_object* mo); +static v8::Local MsgpackToJs(const msgpack_object* mo) { + switch (mo->type) { + case MSGPACK_OBJECT_NIL: + return Nan::Null(); + case MSGPACK_OBJECT_BOOLEAN: + return Nan::New(mo->via.boolean); + case MSGPACK_OBJECT_POSITIVE_INTEGER: + /* Values that fit in 2^53-1 stay as Number; larger become the + * closest Number (legacy behavior). */ + return Nan::New(static_cast(mo->via.u64)); + case MSGPACK_OBJECT_NEGATIVE_INTEGER: + return Nan::New(static_cast(mo->via.i64)); + case MSGPACK_OBJECT_FLOAT32: + case MSGPACK_OBJECT_FLOAT64: + return Nan::New(mo->via.f64); + case MSGPACK_OBJECT_STR: + if (mo->via.str.size == 0) { + return Nan::New("").ToLocalChecked(); + } + return Nan::New(mo->via.str.ptr, mo->via.str.size).ToLocalChecked(); case MSGPACK_OBJECT_BIN: - return Nan::CopyBuffer(mo->via.str.ptr, mo->via.bin.size).ToLocalChecked(); + if (mo->via.bin.size == 0) { + return Nan::NewBuffer(0).ToLocalChecked(); + } + return Nan::CopyBuffer(mo->via.bin.ptr, mo->via.bin.size).ToLocalChecked(); + case MSGPACK_OBJECT_EXT: + /* Fail closed on extension types: callers expecting core JSON-like + * values should not silently receive opaque ext payloads. */ + throw MsgpackException(Error("cannot unpack ext type")); + case MSGPACK_OBJECT_ARRAY: { + v8::Local arr = Nan::New(mo->via.array.size); + for (uint32_t i = 0; i < mo->via.array.size; i++) { + Nan::Set(arr, i, MsgpackToJs(&mo->via.array.ptr[i])); + } + return arr; + } case MSGPACK_OBJECT_MAP: { - Local o = Nan::New(); - - for (uint32_t i = 0; i < mo->via.map.size; i++) { - Nan::Set( - o, - msgpack_to_v8(&mo->via.map.ptr[i].key), - msgpack_to_v8(&mo->via.map.ptr[i].val) - ); + v8::Local obj = Nan::New(); + for (uint32_t i = 0; i < mo->via.map.size; i++) { + const msgpack_object_kv* kv = &mo->via.map.ptr[i]; + v8::Local key = MsgpackToJs(&kv->key); + v8::Local val = MsgpackToJs(&kv->val); + /* DefineOwnProperty, not Set: Set would run the __proto__ setter + * inherited from Object.prototype, letting a wire map replace the + * decoded object's prototype. Every key becomes a plain own, + * enumerable, writable, configurable data property. */ + Nan::MaybeLocal name = Nan::To(key); + /* GCOVR_EXCL_BR_START: keys are decoded nil/bool/number/string/ + * Buffer/Array/plain Object, none of which can throw in ToString. */ + if (name.IsEmpty()) { + throw MsgpackException(Error("cannot unpack map key")); } - - return o; + /* GCOVR_EXCL_BR_STOP */ + Nan::DefineOwnProperty(obj, name.ToLocalChecked(), val); + } + return obj; } - default: - throw MsgpackException("Encountered unknown MesssagePack object type"); - } + /* Every msgpack_object_type value is handled above; this only fires + * if the vendored library grows a new one. */ + throw MsgpackException(Error("Encountered unknown object type")); /* GCOVR_EXCL_BR_LINE */ + } } -// var buf = msgpack.pack(obj[, obj ...]); -// -// Returns a Buffer object representing the serialized state of the provided -// JavaScript object. If more arguments are provided, their serialized state -// will be accumulated to the end of the previous value(s). -// -// Any number of objects can be provided as arguments, and all will be -// serialized to the same bytestream, back-to-back. -static NAN_METHOD(pack) { - Nan::HandleScope scope; +struct SbufPool { + msgpack_sbuffer* list[kSbufferPoolMax]; + size_t length; - msgpack_packer pk; - MsgpackZone mz; - msgpack_sbuffer *sb; + SbufPool() : list(), length(0) {} - if (!sbuffers.empty()) { - sb = sbuffers.top(); - sbuffers.pop(); - } else { - sb = msgpack_sbuffer_new(); + /* Each thread owns its pool, so release the cached sbuffers when the + * thread goes away instead of leaking them per worker. */ + ~SbufPool() { + while (length > 0) { + msgpack_sbuffer_free(list[--length]); } + } - msgpack_packer_init(&pk, sb, msgpack_sbuffer_write); - - for (int i = 0; i < info.Length(); i++) { - msgpack_object mo; - - try { - v8_to_msgpack(info[i], &mo, &mz._mz, 0); - } catch (MsgpackException e) { - return Nan::ThrowError(e.getThrownException()); - } + private: + SbufPool(const SbufPool&); + SbufPool& operator=(const SbufPool&); +}; - if (msgpack_pack_object(&pk, mo)) { - return Nan::ThrowError("Error serializaing object"); - } +/* thread_local, not process-global: a worker thread packing concurrently with + * the main thread would otherwise hand the same sbuffer to both. */ +static thread_local SbufPool sbuf_pool; + +class PackBuffer { + public: + PackBuffer() : sb_(NULL), from_pool_(false) { + if (sbuf_pool.length > 0) { + sb_ = sbuf_pool.list[--sbuf_pool.length]; + from_pool_ = true; + msgpack_sbuffer_clear(sb_); + } else { + sb_ = msgpack_sbuffer_new(); + from_pool_ = false; } + /* GCOVR_EXCL_BR_START: pooled buffers are never NULL and + * msgpack_sbuffer_new only returns NULL out of memory. */ + if (sb_ == NULL) { + throw MsgpackException(Error("Error initializing packing buffer")); + } + /* GCOVR_EXCL_BR_STOP */ + } + + /* Offer the sbuffer back to this thread's pool whether or not it came from + * there: only handing back pooled buffers would leave the pool permanently + * empty, so every pack would malloc and every dtor would free. */ + ~PackBuffer() { + /* sb_ is non-NULL from the ctor on (a throwing ctor runs no dtor) and + * is only cleared on the last line of this function. */ + if (sb_ == NULL) return; /* GCOVR_EXCL_BR_LINE */ + if (sbuf_pool.length == kSbufferPoolMax) { + msgpack_sbuffer_free(sb_); + } else { + sbuf_pool.list[sbuf_pool.length++] = sb_; + } + sb_ = NULL; + } + + msgpack_sbuffer* get() { return sb_; } + bool from_pool() const { return from_pool_; } + + char* release_data(size_t* size) { + *size = sb_->size; + char* data = msgpack_sbuffer_release(sb_); + return data; + } + + private: + PackBuffer(const PackBuffer&); + PackBuffer& operator=(const PackBuffer&); + msgpack_sbuffer* sb_; + bool from_pool_; +}; - Local slowBuffer = Nan::NewBuffer( - sb->data, sb->size, _free_sbuf, (void *)sb - ).ToLocalChecked(); - - return info.GetReturnValue().Set(slowBuffer); +static void MsgpackFree(char* data, void* hint) { + (void)hint; + free(data); } -// var o = msgpack.unpack(buf); -// -// Return the JavaScript object resulting from unpacking the contents of the -// specified buffer. If the buffer does not contain a complete object, the -// undefined value is returned. -static NAN_METHOD(unpack) { - Nan::HandleScope scope; +/* thread_local for the same reason as sbuf_pool: unpack() on a worker must + * not clobber the value the main thread's unpack.bytes_remaining reads. */ +static thread_local int remaining_bytes_in_buffer = 0; - if (info.Length() < 0 || !Buffer::HasInstance(info[0])) { - return Nan::ThrowTypeError("First argument must be a Buffer"); - } +NAN_METHOD(BytesRemaining) { + info.GetReturnValue().Set(Nan::New(remaining_bytes_in_buffer)); +} - Local buf = Nan::To(info[0]).ToLocalChecked(); - - MsgpackZone mz; - msgpack_object mo; - size_t off = 0; - - switch (msgpack_unpack(Buffer::Data(buf), Buffer::Length(buf), &off, &mz._mz, &mo)) { - case MSGPACK_UNPACK_EXTRA_BYTES: - case MSGPACK_UNPACK_SUCCESS: - try { - Nan::Set( - Nan::GetFunction(Nan::New(msgpack_unpack_template)).ToLocalChecked(), - Nan::New("bytes_remaining").ToLocalChecked(), - Nan::New(static_cast(Buffer::Length(buf) - off)) - ); - return info.GetReturnValue().Set(msgpack_to_v8(&mo)); - } catch (MsgpackException e) { - return Nan::ThrowError(e.getThrownException()); - } +NAN_METHOD(Pack) { + try { + PackBuffer buf; + msgpack_packer pk; + msgpack_packer_init(&pk, buf.get(), msgpack_sbuffer_write); - case MSGPACK_UNPACK_CONTINUE: - return; + if (info.Length() == 1) { + JsToMsgpack(&pk, info[0], 0); + } else { + /* GCOVR_EXCL_BR_START: allocation failure only. */ + if (msgpack_pack_array(&pk, info.Length())) { + throw MsgpackException(Error("Error serializing object")); + } + /* GCOVR_EXCL_BR_STOP */ + for (int i = 0; i < info.Length(); i++) { + JsToMsgpack(&pk, info[i], 0); + } + } - default: - return Nan::ThrowError("Error de-serializing object"); + if (buf.from_pool()) { + info.GetReturnValue().Set( + Nan::CopyBuffer(buf.get()->data, buf.get()->size).ToLocalChecked()); + return; } + size_t size = 0; + char* data = buf.release_data(&size); + info.GetReturnValue().Set( + Nan::NewBuffer(data, size, MsgpackFree, NULL).ToLocalChecked()); + } catch (const MsgpackException& e) { /* GCOVR_EXCL_BR_LINE: nothing here throws another type */ + Nan::ThrowError(e.value()); + } } -NAN_MODULE_INIT(init) { - Nan::Set(target, Nan::New("pack").ToLocalChecked(), Nan::GetFunction(Nan::New(pack)).ToLocalChecked()); - - // Go through this mess rather than call NODE_SET_METHOD so that we can set - // a field on the function for 'bytes_remaining'. - msgpack_unpack_template.Reset(Nan::New(unpack)); +NAN_METHOD(Unpack) { + if (info.Length() < 1 || !info[0]->IsObject() || !node::Buffer::HasInstance(info[0])) { + return Nan::ThrowTypeError("First argument must be a Buffer"); + } + + v8::Local buf = Nan::To(info[0]).ToLocalChecked(); + char* data = node::Buffer::Data(buf); + size_t len = node::Buffer::Length(buf); + + remaining_bytes_in_buffer = static_cast(len); + + size_t consumed = 0; + ScanStatus scan = ScanOne(data, len, &consumed); + if (scan == kScanContinue) { + remaining_bytes_in_buffer = static_cast(len); + info.GetReturnValue().Set(Nan::Null()); + return; + } + if (scan == kScanLimit) { + return Nan::ThrowError("msgpack unpack limit exceeded"); + } + if (scan == kScanParse) { + return Nan::ThrowError("Encountered error unpacking buffer"); + } + + msgpack_unpacked result; + msgpack_unpacked_init(&result); + size_t off = 0; + msgpack_unpack_return ret = msgpack_unpack_next(&result, data, len, &off); + remaining_bytes_in_buffer = static_cast(len - off); + + /* ScanOne has already walked the same grammar with limits at or below the + * vendored library's own (511 vs 512 nested containers, the same 1e6 + * element cap), so once it reports kScanOk msgpack_unpack_next can only + * report success. The CONTINUE / PARSE_ERROR / NOMEM arms below are kept + * so a future divergence fails closed rather than reading result.data + * uninitialised. */ + /* Only the SUCCESS disjunct is reachable: the vendored + * msgpack_unpack_next never returns EXTRA_BYTES. */ + if (ret == MSGPACK_UNPACK_SUCCESS || ret == MSGPACK_UNPACK_EXTRA_BYTES) { /* GCOVR_EXCL_BR_LINE */ + try { + v8::Local v = MsgpackToJs(&result.data); + msgpack_unpacked_destroy(&result); + info.GetReturnValue().Set(v); + return; + } catch (const MsgpackException& e) { /* GCOVR_EXCL_BR_LINE: MsgpackToJs throws nothing else */ + msgpack_unpacked_destroy(&result); + return Nan::ThrowError(e.value()); + } + } + + /* GCOVR_EXCL_BR_START: unreachable tail, see above. */ + msgpack_unpacked_destroy(&result); + if (ret == MSGPACK_UNPACK_CONTINUE) { + remaining_bytes_in_buffer = static_cast(len); + info.GetReturnValue().Set(Nan::Null()); + return; + } + Nan::ThrowError("Encountered error unpacking buffer"); + /* GCOVR_EXCL_BR_STOP */ +} - Nan::Set( - target, - Nan::New("unpack").ToLocalChecked(), - Nan::GetFunction(Nan::New(msgpack_unpack_template)).ToLocalChecked() - ); +NAN_MODULE_INIT(Init) { + stack_key.Reset(Nan::New("_msgpack_stack").ToLocalChecked()); + Nan::Set(target, Nan::New("pack").ToLocalChecked(), + Nan::GetFunction(Nan::New(Pack)).ToLocalChecked()); + Nan::Set(target, Nan::New("unpack").ToLocalChecked(), + Nan::GetFunction(Nan::New(Unpack)).ToLocalChecked()); + Nan::Set(target, Nan::New("bytesRemaining").ToLocalChecked(), + Nan::GetFunction(Nan::New(BytesRemaining)).ToLocalChecked()); } -NODE_MODULE(msgpackBinding, init); -// vim:ts=4 sw=4 et +/* Context-aware: without this the addon refuses to load in a worker_threads + * Worker ("Module did not self-register"). NAN_MODULE_WORKER_ENABLED is the + * right wrapper here -- Init is a NAN_MODULE_INIT, i.e. a one-argument + * function, while NODE_MODULE_CONTEXT_AWARE expects a four-argument + * addon_context_register_func and casts between the mismatched function + * pointer types. */ +NAN_MODULE_WORKER_ENABLED(msgpackBinding, Init) + +} // namespace diff --git a/test/benchmark/benchmark.js b/test/benchmark/benchmark.js index 8fbad79..c98e08d 100644 --- a/test/benchmark/benchmark.js +++ b/test/benchmark/benchmark.js @@ -1,204 +1,63 @@ -var fs = require('fs'), - msgpack = require("../../lib/msgpack"), - stub = require("../fixtures/stub"); - -var DATA_TEMPLATE = {'abcdef' : 1, 'qqq' : 13, '19' : [1, 2, 3, 4]}; -var DATA = []; - -for (var i = 0; i < 1000000; i++) { - DATA.push(JSON.parse(JSON.stringify(DATA_TEMPLATE))); -} - -function _set_up(callback) { - this.backup = {}; - callback(); -} - -function _tear_down(callback) { - callback(); -} - -exports.benchmark = { - setUp : _set_up, - tearDown : _tear_down, - 'JSON.stringify faster than msgpack.pack with array of 1m objects' : function (test) { - console.log(); - var jsonStr; - var now = Date.now(); - jsonStr = JSON.stringify(DATA); - var stringifyTime = (Date.now() - now); - - var mpBuf; - now = Date.now(); - mpBuf = msgpack.pack(DATA); - var packTime = (Date.now() - now); - - console.log( - "msgpack.pack: "+packTime+"ms, JSON.stringify: "+stringifyTime+"ms" - ); - console.log( - "ratio of JSON.stringify/msgpack.pack: " + stringifyTime/packTime - ); - test.expect(1); - test.ok( - packTime > stringifyTime, - "msgpack.pack: "+packTime+"ms, JSON.stringify: "+stringifyTime+"ms" - ); - test.done(); - }, -// 'JSON.parse faster than msgpack.unpack with array of 1m objects' : function (test) { -// console.log(); -// var jsonStr; -// jsonStr = JSON.stringify(DATA); -// -// var mpBuf; -// mpBuf = msgpack.pack(DATA); +#!/usr/bin/env node +// Standalone throughput benchmark: JSON vs. msgpack on a small object. // -// var now = Date.now(); -// JSON.parse(jsonStr); -// var parseTime = (Date.now() - now); +// npm run bench +// node test/benchmark/benchmark.js // -// now = Date.now(); -// msgpack.unpack(mpBuf); -// var unpackTime = (Date.now() - now); -// -// console.log( -// "msgpack.unpack: "+unpackTime+"ms, JSON.parse: "+parseTime+"ms" -// ); -// console.log("ratio of parseTime/msgpack.unpack: " + parseTime/unpackTime); -// test.expect(1); -// test.ok( -// unpackTime > parseTime, -// "msgpack.unpack: "+unpackTime+"ms, JSON.parse: "+parseTime+"ms" -// ); -// test.done(); -// }, - 'JSON.stringify faster than msgpack.pack over 1m calls' : function (test) { - console.log(); +// This only measures. It does not assert that one encoder beats the other: +// the ratio moves with the V8 version, the object shape, and the machine. - var jsonStr; - var now = Date.now(); - DATA.forEach(function(d) { - jsonStr = JSON.stringify(d); - }); - var stringifyTime = (Date.now() - now); +'use strict'; - var mpBuf; - now = Date.now(); - DATA.forEach(function(d) { - mpBuf = msgpack.pack(d); - }); - var packTime = (Date.now() - now); +const os = require('os'); +const msgpack = require('../../lib/msgpack'); - console.log( - "msgpack.pack: "+packTime+"ms, JSON.stringify: "+stringifyTime+"ms" - ); - console.log( - "ratio of msgpack.pack/JSON.stringify: " + packTime/stringifyTime - ); - test.expect(1); - test.ok( - stringifyTime < packTime && packTime/stringifyTime < 6, - "msgpack.pack: "+packTime+"ms, JSON.stringify: "+stringifyTime+"ms" - ); - test.done(); - }, - 'JSON.parse faster than msgpack.unpack over 1m calls' : function (test) { - console.log(); - var jsonStr; +const DATA = { abcdef: 1, qqq: 13, 19: [1, 2, 3, 4] }; +const ITERATIONS = 500000; +const WARMUP = 50000; - DATA.forEach(function(d) { - jsonStr = JSON.stringify(d); - }); +function time(fn, count) { + const start = process.hrtime.bigint(); + for (let i = 0; i < count; i++) { + fn(); + } + return Number(process.hrtime.bigint() - start) / 1e6; +} - var mpBuf; - DATA.forEach(function(d) { - mpBuf = msgpack.pack(d); - }); +const CASES = [ + ['JSON.stringify()', () => JSON.stringify(DATA)], + ['JSON.parse(JSON.stringify())', () => JSON.parse(JSON.stringify(DATA))], + ['msgpack.pack()', () => msgpack.pack(DATA)], + ['msgpack.unpack(msgpack.pack())', () => msgpack.unpack(msgpack.pack(DATA))] +]; + +function cpuClass() { + const cpus = os.cpus(); + const model = cpus.length > 0 ? cpus[0].model : 'unknown'; + // Containers on some platforms report no model string; fall back to arch. + const name = !model || model === 'unknown' ? `${os.arch()} (model not reported)` : model; + return `${name} x ${cpus.length}, ${(os.totalmem() / 1024 ** 3).toFixed(1)} GiB RAM`; +} - var now = Date.now(); - DATA.forEach(function(d) { - JSON.parse(jsonStr); - }); - var parseTime = (Date.now() - now); +console.log(`node ${process.version}`); +console.log(`v8 ${process.versions.v8}`); +console.log(`platform ${os.platform()} ${os.release()} (${os.arch()})`); +console.log(`cpu ${cpuClass()}`); +console.log(`data ${JSON.stringify(DATA)}`); +console.log(`iterations ${ITERATIONS.toLocaleString('en-US')}`); +console.log(''); - now = Date.now(); - DATA.forEach(function(d) { - msgpack.unpack(mpBuf); - }); - var unpackTime = (Date.now() - now); +for (const [, fn] of CASES) { + time(fn, WARMUP); +} +for (const [name, fn] of CASES) { + const ms = time(fn, ITERATIONS); console.log( - "msgpack.unpack: "+unpackTime+"ms, JSON.parse: "+parseTime+"ms" - ); - console.log("ratio of JSON.parse/msgpack.unpack: " + unpackTime/parseTime); - test.expect(1); - test.ok( - parseTime < unpackTime && unpackTime/parseTime < 5, - "msgpack.unpack: "+unpackTime+"ms, JSON.parse: "+parseTime+"ms" + `${name.padEnd(32)} ${ms.toFixed(0).padStart(7)} ms (${(ms / 1000).toFixed(2)} s)` ); - test.done(); - }, - 'output above is from three runs on a 1m element array of objects' : function (test) { - console.log(); - for (var i = 0; i < 3; i++) { - var mpBuf; - var now = Date.now(); - mpBuf = msgpack.pack(DATA); - console.log('msgpack pack: ' + (Date.now() - now) + ' ms'); - - now = Date.now(); - msgpack.unpack(mpBuf); - console.log('msgpack unpack: ' + (Date.now() - now) + ' ms'); - - var jsonStr; - now = Date.now(); - jsonStr = JSON.stringify(DATA); - console.log('json pack: ' + (Date.now() - now) + ' ms'); - - now = Date.now(); - JSON.parse(jsonStr); - console.log('json unpack: ' + (Date.now() - now) + ' ms'); - console.log(); - } - - test.expect(1); - test.ok(1); - test.done(); - }, - 'output above is from three runs of 1m individual calls' : function (test) { - console.log(); - for (var i = 0; i < 3; i++) { - var mpBuf; - var now = Date.now(); - DATA.forEach(function(d) { - mpBuf = msgpack.pack(d); - }); - console.log('msgpack pack: ' + (Date.now() - now) + ' ms'); - - now = Date.now(); - DATA.forEach(function(d) { - msgpack.unpack(mpBuf); - }); - console.log('msgpack unpack: ' + (Date.now() - now) + ' ms'); - - var jsonStr; - now = Date.now(); - DATA.forEach(function(d) { - jsonStr = JSON.stringify(d); - }); - console.log('json pack: ' + (Date.now() - now) + ' ms'); +} - now = Date.now(); - DATA.forEach(function(d) { - JSON.parse(jsonStr); - }); - console.log('json unpack: ' + (Date.now() - now) + ' ms'); - console.log(); - } +process.exit(0); - test.expect(1); - test.ok(1); - test.done(); - } -}; +// vim:ts=4 sw=4 et filetype=javascript diff --git a/test/cli.test.js b/test/cli.test.js new file mode 100644 index 0000000..1e27297 --- /dev/null +++ b/test/cli.test.js @@ -0,0 +1,124 @@ +'use strict'; + +/* + * Error and edge paths of bin/json2msgpack and bin/msgpack2json. The happy + * paths live in msgpack.test.js; these cover the branches that set + * process.exitCode and write to stderr. + */ + +const { describe, it } = require('node:test'); +const assert = require('node:assert/strict'); +const path = require('path'); +const { spawnSync } = require('child_process'); +const msgpack = require('../lib/msgpack'); + +const bin = (name) => path.join(__dirname, '..', 'bin', name); + +function run(name, input) { + const r = spawnSync(process.execPath, [bin(name)], { + input, + maxBuffer: 1 << 22, + }); + assert.equal(r.error, undefined); + assert.equal(r.signal, null, 'child must not be killed by a signal'); + return { + status: r.status, + stdout: r.stdout, + stderr: r.stderr.toString('utf8'), + }; +} + +describe('json2msgpack error paths', () => { + it('exits 1 with a message on invalid JSON', () => { + const r = run('json2msgpack', '{not json'); + assert.equal(r.status, 1); + assert.match(r.stderr, /json2msgpack: invalid JSON on stdin: /); + assert.equal(r.stdout.length, 0); + }); + + it('exits 1 on empty stdin', () => { + /* JSON.parse('') throws, so empty input is an invalid-JSON error. */ + const r = run('json2msgpack', ''); + assert.equal(r.status, 1); + assert.match(r.stderr, /json2msgpack: invalid JSON on stdin: /); + }); + + it('exits 1 when pack rejects the parsed value', () => { + /* JSON.parse can produce arbitrarily deep nesting, which pack caps at + * 512 levels. This is the only pack failure reachable from real JSON: + * every other JSON value type packs. */ + const deep = '['.repeat(600) + '1' + ']'.repeat(600); + const r = run('json2msgpack', deep); + assert.equal(r.status, 1); + assert.match(r.stderr, /json2msgpack: Cowardly refusing to pack object nested/); + assert.equal(r.stdout.length, 0); + }); + + it('accepts JSON split across several stdin chunks', () => { + const big = JSON.stringify({ s: 'x'.repeat(200000) }); + const r = run('json2msgpack', big); + assert.equal(r.status, 0); + assert.deepEqual(msgpack.unpack(r.stdout), JSON.parse(big)); + }); + + it('packs a bare JSON scalar', () => { + for (const [text, want] of [['null', null], ['true', true], ['42', 42], ['"s"', 's']]) { + const r = run('json2msgpack', text); + assert.equal(r.status, 0, text); + assert.equal(msgpack.unpack(r.stdout), want, text); + } + }); +}); + +describe('msgpack2json error paths', () => { + it('exits 1 with a message on an unparseable byte', () => { + const r = run('msgpack2json', Buffer.from([0xc1])); + assert.equal(r.status, 1); + assert.match(r.stderr, /msgpack2json: Encountered error unpacking buffer/); + assert.equal(r.stdout.length, 0); + }); + + it('exits 1 when unpack rejects an oversized header', () => { + const r = run('msgpack2json', Buffer.from([0xdd, 0xff, 0x00, 0x00, 0x00])); + assert.equal(r.status, 1); + assert.match(r.stderr, /msgpack2json: msgpack unpack limit exceeded/); + }); + + it('exits 1 on incomplete MessagePack data', () => { + /* bin8 tag with no length byte: nothing can be consumed. */ + const r = run('msgpack2json', Buffer.from([0xc4])); + assert.equal(r.status, 1); + assert.match(r.stderr, /msgpack2json: incomplete MessagePack data on stdin/); + assert.equal(r.stdout.length, 0); + }); + + it('exits 1 when a trailing message is incomplete', () => { + /* One good frame is printed, then the truncated tail is reported. */ + const input = Buffer.concat([msgpack.pack('one'), Buffer.from([0xa5, 0x61])]); + const r = run('msgpack2json', input); + assert.equal(r.status, 1); + assert.equal(r.stdout.toString('utf8'), '"one"\n'); + assert.match(r.stderr, /incomplete MessagePack data on stdin/); + }); + + it('exits 0 with no output on empty stdin', () => { + const r = run('msgpack2json', Buffer.alloc(0)); + assert.equal(r.status, 0); + assert.equal(r.stdout.length, 0); + assert.equal(r.stderr, ''); + }); + + it('prints a decoded nil frame rather than treating it as incomplete', () => { + const input = Buffer.concat([msgpack.pack(null), msgpack.pack(0)]); + const r = run('msgpack2json', input); + assert.equal(r.status, 0); + assert.deepEqual(r.stdout.toString('utf8').trim().split('\n'), ['null', '0']); + }); + + it('reads MessagePack split across several stdin chunks', () => { + const value = { s: 'y'.repeat(200000) }; + const r = run('msgpack2json', msgpack.pack(value)); + assert.equal(r.status, 0); + assert.deepEqual(JSON.parse(r.stdout.toString('utf8')), value); + }); +}); diff --git a/test/coverage-native.test.js b/test/coverage-native.test.js new file mode 100644 index 0000000..4756d0f --- /dev/null +++ b/test/coverage-native.test.js @@ -0,0 +1,566 @@ +'use strict'; + +/* + * Wire-level coverage for src/msgpack.cc: every MessagePack format family, + * every truncation point ScanOne can bail out of, every fail-closed limit, + * and the pack-side type dispatch. Buffers are hand-built rather than + * produced by pack() so families pack() never emits (ext, float32, str8, + * array32, ...) are still exercised. + */ + +const { describe, it } = require('node:test'); +const assert = require('node:assert/strict'); +const path = require('path'); +const { Worker } = require('worker_threads'); +const msgpack = require('../lib/msgpack'); +const binding = require('../build/Release/msgpackBinding'); + +const b = (...bytes) => Buffer.from(bytes); + +/* A buffer ScanOne cannot finish reads as "incomplete": null, and every byte + * still pending. */ +function assertIncomplete(buf, label) { + assert.equal(msgpack.unpack(buf), null, label); + assert.equal(msgpack.unpack.bytes_remaining, buf.length, label + ' remaining'); +} + +describe('unpack format families', () => { + it('unpacks positive and negative fixint', () => { + assert.equal(msgpack.unpack(b(0x00)), 0); + assert.equal(msgpack.unpack(b(0x7f)), 127); + assert.equal(msgpack.unpack(b(0xff)), -1); + assert.equal(msgpack.unpack(b(0xe0)), -32); + }); + + it('unpacks nil, false and true', () => { + assert.equal(msgpack.unpack(b(0xc0)), null); + assert.equal(msgpack.unpack(b(0xc2)), false); + assert.equal(msgpack.unpack(b(0xc3)), true); + }); + + it('unpacks uint8 through uint64', () => { + assert.equal(msgpack.unpack(b(0xcc, 0xff)), 255); + assert.equal(msgpack.unpack(b(0xcd, 0xff, 0xff)), 65535); + assert.equal(msgpack.unpack(b(0xce, 0xff, 0xff, 0xff, 0xff)), 4294967295); + assert.equal( + msgpack.unpack(b(0xcf, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01)), + 9007199254740993 /* nearest double to 2^53+1 */ + ); + }); + + it('unpacks int8 through int64', () => { + assert.equal(msgpack.unpack(b(0xd0, 0x80)), -128); + assert.equal(msgpack.unpack(b(0xd1, 0x80, 0x00)), -32768); + assert.equal(msgpack.unpack(b(0xd2, 0x80, 0x00, 0x00, 0x00)), -2147483648); + assert.equal( + msgpack.unpack(b(0xd3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff)), + -1 + ); + }); + + it('unpacks float32 and float64', () => { + /* 0xca is a format pack() never emits, so only a hand-built buffer + * reaches the MSGPACK_OBJECT_FLOAT32 arm. */ + assert.equal(msgpack.unpack(b(0xca, 0x3f, 0x80, 0x00, 0x00)), 1); + assert.equal(msgpack.unpack(b(0xca, 0xc0, 0x00, 0x00, 0x00)), -2); + const f64 = Buffer.alloc(9); + f64[0] = 0xcb; + f64.writeDoubleBE(1.5, 1); + assert.equal(msgpack.unpack(f64), 1.5); + }); + + it('unpacks fixstr, str8, str16 and str32', () => { + assert.equal(msgpack.unpack(b(0xa3, 0x61, 0x62, 0x63)), 'abc'); + assert.equal(msgpack.unpack(b(0xd9, 0x03, 0x61, 0x62, 0x63)), 'abc'); + assert.equal(msgpack.unpack(b(0xda, 0x00, 0x03, 0x61, 0x62, 0x63)), 'abc'); + assert.equal( + msgpack.unpack(b(0xdb, 0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63)), + 'abc' + ); + }); + + it('unpacks an empty fixstr as the empty string', () => { + assert.equal(msgpack.unpack(b(0xa0)), ''); + assert.equal(msgpack.unpack(msgpack.pack('')), ''); + }); + + it('unpacks bin8, bin16 and bin32 as Buffers', () => { + for (const wire of [ + b(0xc4, 0x03, 0x61, 0x62, 0x63), + b(0xc5, 0x00, 0x03, 0x61, 0x62, 0x63), + b(0xc6, 0x00, 0x00, 0x00, 0x03, 0x61, 0x62, 0x63), + ]) { + const got = msgpack.unpack(wire); + assert.ok(Buffer.isBuffer(got)); + assert.equal(got.toString('utf8'), 'abc'); + } + }); + + it('unpacks an empty bin as a zero-length Buffer', () => { + const got = msgpack.unpack(b(0xc4, 0x00)); + assert.ok(Buffer.isBuffer(got)); + assert.equal(got.length, 0); + assert.equal(msgpack.unpack(msgpack.pack(Buffer.alloc(0))).length, 0); + }); + + it('unpacks fixarray, array16 and array32', () => { + assert.deepEqual(msgpack.unpack(b(0x92, 0x01, 0x02)), [1, 2]); + assert.deepEqual(msgpack.unpack(b(0xdc, 0x00, 0x02, 0x01, 0x02)), [1, 2]); + assert.deepEqual( + msgpack.unpack(b(0xdd, 0x00, 0x00, 0x00, 0x02, 0x01, 0x02)), + [1, 2] + ); + assert.deepEqual(msgpack.unpack(b(0x90)), []); + }); + + it('unpacks fixmap, map16 and map32', () => { + assert.deepEqual(msgpack.unpack(b(0x81, 0xa1, 0x61, 0x01)), { a: 1 }); + assert.deepEqual(msgpack.unpack(b(0xde, 0x00, 0x01, 0xa1, 0x61, 0x01)), { a: 1 }); + assert.deepEqual( + msgpack.unpack(b(0xdf, 0x00, 0x00, 0x00, 0x01, 0xa1, 0x61, 0x01)), + { a: 1 } + ); + assert.deepEqual(msgpack.unpack(b(0x80)), {}); + }); + + it('coerces a non-string map key to a string property', () => { + /* map of {1: 2} on the wire: the key arrives as a Number and has to be + * stringified before DefineOwnProperty. */ + assert.deepEqual(msgpack.unpack(b(0x81, 0x01, 0x02)), { 1: 2 }); + /* nil and boolean keys stringify too. */ + assert.deepEqual(msgpack.unpack(b(0x81, 0xc0, 0x01)), { null: 1 }); + assert.deepEqual(msgpack.unpack(b(0x81, 0xc3, 0x01)), { true: 1 }); + }); + + it('unpacks nested containers', () => { + assert.deepEqual(msgpack.unpack(b(0x91, 0x81, 0xa1, 0x61, 0x91, 0x02)), [ + { a: [2] }, + ]); + }); +}); + +describe('unpack truncation returns null without consuming', () => { + it('treats an empty buffer as incomplete', () => { + assertIncomplete(Buffer.alloc(0), 'empty'); + }); + + it('treats a truncated fixed-width header as incomplete', () => { + const cases = [ + [0xca], + [0xca, 0x00, 0x00], + [0xcb], + [0xcb, 0x00, 0x00, 0x00], + [0xcc], + [0xcd], + [0xcd, 0x00], + [0xce], + [0xce, 0x00, 0x00], + [0xcf], + [0xcf, 0x00, 0x00, 0x00], + [0xd0], + [0xd1], + [0xd1, 0x00], + [0xd2], + [0xd2, 0x00, 0x00], + [0xd3], + [0xd3, 0x00, 0x00, 0x00], + ]; + for (const c of cases) assertIncomplete(b(...c), '0x' + c[0].toString(16)); + }); + + it('treats a truncated fixext as incomplete', () => { + const cases = [ + [0xd4], + [0xd4, 0x01], + [0xd5, 0x01], + [0xd6, 0x01, 0x00], + [0xd7, 0x01, 0x00], + [0xd8, 0x01, 0x00], + ]; + for (const c of cases) assertIncomplete(b(...c), '0x' + c[0].toString(16)); + }); + + it('treats a truncated str header or payload as incomplete', () => { + assertIncomplete(b(0xa3, 0x61), 'fixstr payload'); + assertIncomplete(b(0xd9), 'str8 length'); + assertIncomplete(b(0xd9, 0x03, 0x61), 'str8 payload'); + assertIncomplete(b(0xda, 0x00), 'str16 length'); + assertIncomplete(b(0xda, 0x00, 0x03, 0x61), 'str16 payload'); + assertIncomplete(b(0xdb, 0x00, 0x00), 'str32 length'); + assertIncomplete(b(0xdb, 0x00, 0x00, 0x00, 0x03, 0x61), 'str32 payload'); + }); + + it('treats a truncated bin header or payload as incomplete', () => { + assertIncomplete(b(0xc4), 'bin8 length'); + assertIncomplete(b(0xc4, 0x03, 0x61), 'bin8 payload'); + assertIncomplete(b(0xc5, 0x00), 'bin16 length'); + assertIncomplete(b(0xc5, 0x00, 0x03, 0x61), 'bin16 payload'); + assertIncomplete(b(0xc6, 0x00, 0x00), 'bin32 length'); + assertIncomplete(b(0xc6, 0x00, 0x00, 0x00, 0x03, 0x61), 'bin32 payload'); + }); + + it('treats a truncated ext header, type byte or payload as incomplete', () => { + assertIncomplete(b(0xc7), 'ext8 length'); + assertIncomplete(b(0xc7, 0x01), 'ext8 type byte'); + assertIncomplete(b(0xc7, 0x03, 0x01, 0x61), 'ext8 payload'); + assertIncomplete(b(0xc8, 0x00), 'ext16 length'); + assertIncomplete(b(0xc8, 0x00, 0x01), 'ext16 type byte'); + assertIncomplete(b(0xc8, 0x00, 0x03, 0x01, 0x61), 'ext16 payload'); + assertIncomplete(b(0xc9, 0x00, 0x00), 'ext32 length'); + assertIncomplete(b(0xc9, 0x00, 0x00, 0x00, 0x01), 'ext32 type byte'); + assertIncomplete(b(0xc9, 0x00, 0x00, 0x00, 0x03, 0x01, 0x61), 'ext32 payload'); + }); + + it('treats a truncated container header or payload as incomplete', () => { + assertIncomplete(b(0x91), 'fixarray element'); + assertIncomplete(b(0x81), 'fixmap key'); + assertIncomplete(b(0x81, 0xa1, 0x61), 'fixmap value'); + assertIncomplete(b(0xdc, 0x00), 'array16 length'); + assertIncomplete(b(0xdc, 0x00, 0x02, 0x01), 'array16 elements'); + assertIncomplete(b(0xdd, 0x00, 0x00), 'array32 length'); + assertIncomplete(b(0xdd, 0x00, 0x00, 0x00, 0x05), 'array32 elements'); + assertIncomplete(b(0xde, 0x00), 'map16 length'); + assertIncomplete(b(0xde, 0x00, 0x02, 0xa1, 0x61, 0x01), 'map16 pairs'); + assertIncomplete(b(0xdf, 0x00, 0x00), 'map32 length'); + assertIncomplete(b(0xdf, 0x00, 0x00, 0x00, 0x05), 'map32 pairs'); + }); +}); + +describe('unpack fail-closed limits', () => { + const tooManyItems = 1000001; /* kMaxContainer + 1 */ + const be32 = (tag, n) => { + const buf = Buffer.alloc(5); + buf[0] = tag; + buf.writeUInt32BE(n, 1); + return buf; + }; + + it('rejects array32 and map32 above kMaxContainer', () => { + assert.throws(() => msgpack.unpack(be32(0xdd, tooManyItems)), /limit exceeded/); + assert.throws(() => msgpack.unpack(be32(0xdf, tooManyItems)), /limit exceeded/); + }); + + it('rejects str32, bin32 and ext32 above kMaxBytes', () => { + const tooManyBytes = 32 * 1024 * 1024 + 1; + assert.throws(() => msgpack.unpack(be32(0xdb, tooManyBytes)), /limit exceeded/); + assert.throws(() => msgpack.unpack(be32(0xc6, tooManyBytes)), /limit exceeded/); + const ext = Buffer.concat([be32(0xc9, tooManyBytes), b(0x01)]); + assert.throws(() => msgpack.unpack(ext), /limit exceeded/); + }); + + it('rejects a container nested past kMaxDepth even when complete', () => { + const deep = (n) => Buffer.concat([Buffer.alloc(n, 0x91), b(0x01)]); + assert.deepEqual(msgpack.unpack(deep(1)), [1]); + assert.throws(() => msgpack.unpack(deep(512)), /limit exceeded/); + /* map16 nesting takes the same CheckContainer depth guard. */ + const deepMap = Buffer.concat([ + Buffer.alloc(600, 0x81), + b(0xa1, 0x61, 0x01), + ]); + assert.throws(() => msgpack.unpack(deepMap), /limit exceeded/); + }); +}); + +describe('unpack parse errors', () => { + it('rejects the never-used byte 0xc1', () => { + assert.throws(() => msgpack.unpack(b(0xc1)), /error unpacking buffer/); + /* 0xc1 nested inside a container is rejected too. */ + assert.throws(() => msgpack.unpack(b(0x91, 0xc1)), /error unpacking buffer/); + }); + + it('refuses to decode every ext family', () => { + const wires = { + fixext1: b(0xd4, 0x01, 0x00), + fixext2: b(0xd5, 0x01, 0x00, 0x00), + fixext4: b(0xd6, 0x01, 0x00, 0x00, 0x00, 0x00), + fixext8: Buffer.concat([b(0xd7, 0x01), Buffer.alloc(8)]), + fixext16: Buffer.concat([b(0xd8, 0x01), Buffer.alloc(16)]), + ext8: b(0xc7, 0x02, 0x01, 0x00, 0x00), + ext16: b(0xc8, 0x00, 0x02, 0x01, 0x00, 0x00), + ext32: b(0xc9, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00), + }; + for (const [name, wire] of Object.entries(wires)) { + assert.throws(() => msgpack.unpack(wire), /cannot unpack ext type/, name); + } + /* An ext buried in a container is rejected on the way out too. */ + assert.throws( + () => msgpack.unpack(b(0x81, 0xa1, 0x61, 0xd4, 0x01, 0x00)), + /cannot unpack ext type/ + ); + }); + + it('rejects a non-Buffer argument', () => { + assert.throws(() => msgpack.unpack(), /must be a Buffer/); + assert.throws(() => msgpack.unpack(5), /must be a Buffer/); + assert.throws(() => msgpack.unpack('abc'), /must be a Buffer/); + assert.throws(() => msgpack.unpack({}), /must be a Buffer/); + assert.throws(() => msgpack.unpack(null), /must be a Buffer/); + }); +}); + +describe('unpack bytes_remaining', () => { + it('reports zero when the buffer is fully consumed', () => { + assert.equal(msgpack.unpack(b(0x92, 0x01, 0x02))[1], 2); + assert.equal(msgpack.unpack.bytes_remaining, 0); + }); + + it('reports the trailing byte count for extra data', () => { + assert.equal(msgpack.unpack(b(0x01, 0x02, 0x03)), 1); + assert.equal(msgpack.unpack.bytes_remaining, 2); + }); +}); + +describe('pack type dispatch', () => { + it('packs undefined as nil', () => { + assert.equal(msgpack.unpack(msgpack.pack(undefined)), null); + assert.deepEqual(msgpack.unpack(msgpack.pack([undefined, null])), [null, null]); + }); + + it('packs no arguments as an empty array', () => { + assert.deepEqual(msgpack.unpack(msgpack.pack()), []); + }); + + it('packs multiple arguments as an array', () => { + assert.deepEqual(msgpack.unpack(msgpack.pack(1, 'two', [3])), [1, 'two', [3]]); + }); + + it('packs non-finite numbers as doubles', () => { + assert.equal(msgpack.unpack(msgpack.pack(Infinity)), Infinity); + assert.equal(msgpack.unpack(msgpack.pack(-Infinity)), -Infinity); + assert.ok(Number.isNaN(msgpack.unpack(msgpack.pack(NaN)))); + for (const wire of [Infinity, -Infinity, NaN].map((n) => msgpack.pack(n))) { + assert.equal(wire[0], 0xcb, 'float64 tag'); + } + }); + + it('packs non-integral numbers as doubles', () => { + assert.equal(msgpack.unpack(msgpack.pack(1.5)), 1.5); + assert.equal(msgpack.unpack(msgpack.pack(-1.5)), -1.5); + }); + + it('packs integers across the signed and unsigned edges', () => { + const cases = [ + 0, 1, -1, 127, -32, 255, -128, 65535, -32768, + 4294967295, -2147483648, 2 ** 53, -(2 ** 53), + Number.MAX_SAFE_INTEGER, -Number.MAX_SAFE_INTEGER, + ]; + for (const n of cases) { + assert.equal(msgpack.unpack(msgpack.pack(n)), n, String(n)); + } + /* 2^63 and -2^63 still take the integer path (they fit uint64/int64). */ + assert.equal(msgpack.unpack(msgpack.pack(2 ** 63)), 2 ** 63); + assert.equal(msgpack.unpack(msgpack.pack(-(2 ** 63))), -(2 ** 63)); + /* One ulp below 2^64 is the largest double that survives the uint64 + * cast; the next one up must fall through to the double path. */ + assert.equal(msgpack.pack(2 ** 64 - 2048)[0], 0xcf); + assert.equal(msgpack.pack(2 ** 64)[0], 0xcb); + assert.equal(msgpack.pack(-(2 ** 64))[0], 0xcb); + }); + + it('packs booleans as true/false, not integers', () => { + assert.equal(msgpack.pack(true)[0], 0xc3); + assert.equal(msgpack.pack(false)[0], 0xc2); + assert.equal(msgpack.unpack(msgpack.pack(false)), false); + }); + + it('refuses to pack a Symbol or a BigInt', () => { + assert.throws(() => msgpack.pack(Symbol('x')), /cannot pack object/); + assert.throws(() => msgpack.pack(10n), /cannot pack object/); + }); + + it('refuses to pack a function', () => { + assert.throws(() => msgpack.pack(() => {}), /cannot pack function/); + assert.throws(() => msgpack.pack({ f: function () {} }), /cannot pack function/); + }); + + it('packs an empty array and an empty object', () => { + assert.deepEqual(msgpack.unpack(msgpack.pack([])), []); + assert.deepEqual(msgpack.unpack(msgpack.pack({})), {}); + }); + + it('reuses the thread-local sbuffer pool on the second pack', () => { + /* First pack allocates and hands the sbuffer to the pool; the second + * takes the pooled path, which copies rather than releasing. */ + const first = msgpack.pack({ a: 1 }); + const second = msgpack.pack({ a: 1 }); + assert.deepEqual(first, second); + for (let i = 0; i < 50; i++) { + assert.deepEqual(msgpack.unpack(msgpack.pack({ i })), { i }); + } + }); +}); + +describe('pack Date handling', () => { + it('packs an invalid Date as the string "Invalid Date" fails closed', () => { + /* toISOString throws RangeError for an invalid Date; CallNoArgs must + * surface that as a catchable JS error, not abort. */ + assert.throws(() => msgpack.pack(new Date(NaN)), /Invalid time value/); + }); + + it('refuses a Date whose toISOString is not callable', () => { + const d = new Date('2000-06-13T00:00:00.000Z'); + d.toISOString = 42; + assert.throws(() => msgpack.pack(d), /cannot pack Date/); + }); + + it('rethrows from a Date whose toISOString throws', () => { + const d = new Date('2000-06-13T00:00:00.000Z'); + d.toISOString = () => { + throw new Error('nope'); + }; + assert.throws(() => msgpack.pack(d), /^Error: nope$/); + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); + + it('reads toISOString through a throwing getter without aborting', () => { + const d = new Date('2000-06-13T00:00:00.000Z'); + Object.defineProperty(d, 'toISOString', { + get() { + throw new Error('trap'); + }, + }); + assert.throws(() => msgpack.pack(d), /^Error: trap$/); + }); +}); + +describe('pack toJSON handling', () => { + it('rethrows when toJSON throws', () => { + assert.throws( + () => + msgpack.pack({ + toJSON() { + throw new Error('boom'); + }, + }), + /^Error: boom$/ + ); + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); + + it('rethrows when a nested toJSON throws', () => { + const o = { + inner: { + toJSON() { + throw new Error('boom'); + }, + }, + }; + assert.throws(() => msgpack.pack(o), /^Error: boom$/); + }); + + it('rethrows when reading toJSON itself throws', () => { + const o = {}; + Object.defineProperty(o, 'toJSON', { + get() { + throw new Error('trap'); + }, + enumerable: true, + }); + assert.throws(() => msgpack.pack(o), /^Error: trap$/); + }); + + it('unmarks an object after a toJSON failure so it can be packed again', () => { + /* The cycle mark has to come off on the throw path, or the retry would + * look like a circular reference. */ + let fail = true; + const o = { + toJSON() { + if (fail) throw new Error('boom'); + return { ok: 1 }; + }, + }; + assert.throws(() => msgpack.pack(o), /boom/); + fail = false; + assert.deepEqual(msgpack.unpack(msgpack.pack(o)), { ok: 1 }); + }); + + it('honours a toJSON that returns a scalar or a Buffer', () => { + assert.equal(msgpack.unpack(msgpack.pack({ toJSON: () => 7 })), 7); + const got = msgpack.unpack(msgpack.pack({ toJSON: () => Buffer.from('hi') })); + assert.ok(Buffer.isBuffer(got)); + assert.equal(got.toString(), 'hi'); + }); +}); + +describe('pack cycle detection', () => { + it('unmarks a nested array so a repeated sibling is not a cycle', () => { + const shared = [1, 2]; + assert.deepEqual(msgpack.unpack(msgpack.pack([shared, shared])), [ + [1, 2], + [1, 2], + ]); + }); + + it('unmarks a nested object so a repeated sibling is not a cycle', () => { + const shared = { a: 1 }; + assert.deepEqual(msgpack.unpack(msgpack.pack({ x: shared, y: shared })), { + x: { a: 1 }, + y: { a: 1 }, + }); + }); + + it('detects a cycle through an array element', () => { + const a = []; + a.push([a]); + assert.throws(() => msgpack.pack(a), /circular/); + }); + + it('detects a cycle through a nested object', () => { + const o = { a: {} }; + o.a.back = o; + assert.throws(() => msgpack.pack(o), /circular/); + }); + + it('leaves no mark behind after a circular failure', () => { + const o = {}; + o.self = o; + assert.throws(() => msgpack.pack(o), /circular/); + delete o.self; + assert.deepEqual(msgpack.unpack(msgpack.pack(o)), {}); + }); +}); + +describe('binding entry points called directly', () => { + it('rejects unpack with no arguments at all', () => { + /* lib/msgpack.js always forwards one argument, so only a direct call + * reaches the info.Length() < 1 arm of the argument check. */ + assert.throws(() => binding.unpack(), /must be a Buffer/); + }); + + it('exposes bytesRemaining as its own function', () => { + binding.unpack(Buffer.from([0x01, 0x02])); + assert.equal(binding.bytesRemaining(), 1); + }); + + it('packs through the binding without the JS wrapper', () => { + assert.deepEqual(binding.unpack(binding.pack({ a: 1 })), { a: 1 }); + }); +}); + +describe('sbuffer pool saturation', () => { + it('frees rather than pools an sbuffer once the pool is full', (t, done) => { + /* 600 > kSbufferPoolMax (512), so unwinding overflows the pool. */ + const worker = new Worker(path.join(__dirname, 'fixtures', 'deep-pack-worker.js'), { + workerData: { + binding: path.join(__dirname, '..', 'build', 'Release', 'msgpackBinding'), + depth: 600, + }, + resourceLimits: { stackSizeMb: 32 }, + }); + let result; + worker.on('message', (m) => { + result = m; + }); + worker.once('error', done); + worker.once('exit', (code) => { + try { + assert.equal(code, 0); + assert.ok(result.length > 0); + assert.equal(result.stable, true, 'pooled and fresh buffers agree'); + done(); + } catch (err) { + done(err); + } + }); + }); +}); diff --git a/test/fixtures/deep-pack-worker.js b/test/fixtures/deep-pack-worker.js new file mode 100644 index 0000000..21b901e --- /dev/null +++ b/test/fixtures/deep-pack-worker.js @@ -0,0 +1,37 @@ +'use strict'; + +/* + * Recursively packs through toJSON so `depth` PackBuffer objects are alive at + * once. Unwinding then returns them to the thread-local sbuffer pool in one + * burst, which is the only way to drive the pool to kSbufferPoolMax (512) and + * exercise the "pool is full, free it" arm of ~PackBuffer. + * + * It runs on a worker because 512+ nested pack->toJSON->pack frames overflow + * the default main-thread stack; resourceLimits.stackSizeMb gives it room. + */ + +const { parentPort, workerData } = require('worker_threads'); +const binding = require(workerData.binding); + +function nestedPack(depth) { + let value = { v: 1 }; + for (let i = 0; i < depth; i++) { + const inner = value; + value = { + toJSON() { + return binding.pack(inner); + }, + }; + } + return binding.pack(value); +} + +/* Twice: the second run starts with a pool that the first run filled, so the + * "take from pool" arm of the constructor runs at depth too. */ +const first = nestedPack(workerData.depth); +const second = nestedPack(workerData.depth); + +parentPort.postMessage({ + length: first.length, + stable: first.equals(second), +}); diff --git a/test/fixtures/msgpack-worker.js b/test/fixtures/msgpack-worker.js new file mode 100644 index 0000000..660465d --- /dev/null +++ b/test/fixtures/msgpack-worker.js @@ -0,0 +1,93 @@ +'use strict'; + +/* Loaded inside a worker_threads Worker. Requiring the addon here is the + * actual failure in msgpack-node#60: a non-context-aware NODE_MODULE throws + * "Module did not self-register" the second time the .node file is loaded. */ +const { parentPort, workerData } = require('worker_threads'); +const msgpack = require('../../'); + +/* Bail out rather than hang if the main thread never opens the start gate. */ +const GATE_TIMEOUT_MS = 30000; + +/* Build a payload that is unique per worker and per iteration, so a buffer + * leaking between threads shows up as wrong data rather than as luck. */ +function payload(id, i) { + return { + id: id, + i: i, + tag: 'w' + id + '-' + i, + blob: Buffer.from(('x' + id).repeat(1 + (i % 37))), + list: [i, i * 2, i * 3, null, true, 'n' + i], + nested: { depth: { value: id * 100000 + i } } + }; +} + +function run(op) { + switch (op) { + case 'roundtrip': { + const value = { a: 1, b: Buffer.from('hi') }; + const unpacked = msgpack.unpack(msgpack.pack(value)); + return { + a: unpacked.a, + bIsBuffer: Buffer.isBuffer(unpacked.b), + b: unpacked.b.toString('latin1'), + keys: Object.keys(unpacked) + }; + } + case 'cycle': { + const o = { name: 'loop' }; + o.self = o; + try { + msgpack.pack(o); + return { threw: false, message: null }; + } catch (err) { + return { threw: true, message: err.message }; + } + } + case 'unpack-remaining': { + /* A different buffer than the main thread used, leaving a different + * number of trailing bytes behind. */ + const buf = Buffer.concat([msgpack.pack('worker'), Buffer.alloc(7)]); + const value = msgpack.unpack(buf); + return { value: value, bytesRemaining: msgpack.unpack.bytes_remaining }; + } + case 'concurrent-pack': { + /* Many pack/unpack round-trips of distinct payloads, racing the main + * thread and the other workers. Exercises the thread_local sbuf pool: + * a shared pool would hand the same sbuffer to two threads at once. */ + const id = workerData.id; + const iterations = workerData.iterations; + const gate = new Int32Array(workerData.gate); + + /* Announce that the addon is loaded, then block until the main thread + * opens the gate. Spawning a Worker takes far longer than this loop + * does, so without the barrier the main thread would be done packing + * before any worker started and nothing would actually overlap. */ + parentPort.postMessage({ ready: true }); + if (Atomics.load(gate, 0) === 0) { + Atomics.wait(gate, 0, 0, GATE_TIMEOUT_MS); + } + if (Atomics.load(gate, 0) === 0) { + throw new Error('worker ' + id + ' timed out waiting for the start gate'); + } + + for (let i = 0; i < iterations; i++) { + const value = payload(id, i); + const unpacked = msgpack.unpack(msgpack.pack(value)); + if (unpacked.id !== id || unpacked.i !== i || unpacked.tag !== value.tag || + unpacked.nested.depth.value !== value.nested.depth.value || + unpacked.blob.toString('latin1') !== value.blob.toString('latin1') || + unpacked.list.length !== value.list.length || + unpacked.list[5] !== value.list[5]) { + throw new Error('worker ' + id + ' round-trip mismatch at ' + i + ': ' + + JSON.stringify(unpacked)); + } + } + return { id: id, iterations: iterations, ok: true }; + } + default: + throw new Error('unknown op: ' + op); + } +} + +parentPort.postMessage(run(workerData.op)); diff --git a/test/lib/msgpack.js b/test/lib/msgpack.js deleted file mode 100644 index bf4d2d3..0000000 --- a/test/lib/msgpack.js +++ /dev/null @@ -1,265 +0,0 @@ -var msgpack = require("../../lib/msgpack"), - stub = require("../fixtures/stub"); - -function _set_up(callback) { - this.backup = {}; - - this.testCircular = function(data, test) { - try { - msgpack.pack(data); - test.ok(false, 'expected exception'); - } catch (e) { - test.equal( - e.message, - 'Cowardly refusing to pack object with circular reference' - ); - } - }; - - callback(); -} - -function _tear_down(callback) { - callback(); -} - -exports.msgpack = { - setUp : _set_up, - tearDown : _tear_down, - 'should be object' : function (test) { - test.expect(2); - test.isNotNull(msgpack); - test.isObject(msgpack); - test.done(); - }, - 'pack should return a Buffer object' : function (test) { - test.expect(2); - var buf = msgpack.pack('abcdef'); - test.isNotNull(buf); - test.isBuffer(buf); - test.done(); - }, - 'test for string equality' : function (test) { - test.expect(1); - test.deepEqual('abcdef', msgpack.unpack(msgpack.pack('abcdef'))); - test.done(); - }, -// 'test unpacking a buffer' : function (test) { -// test.expect(1); -// var testBuffer = new Buffer([0x00, 0x01, 0x02]); -// test.deepEqual(testBuffer, msgpack.unpack(msgpack.pack(testBuffer), true)); -// test.done(); -// }, - 'test for numeric equality' : function (test) { - test.expect(2); - test.deepEqual(123, msgpack.unpack(msgpack.pack(123))); - test.isNumber(msgpack.unpack(msgpack.pack(123))); - test.done(); - }, - 'test for null' : function (test) { - test.expect(2); - test.deepEqual(null, msgpack.unpack(msgpack.pack(null))); - test.isNull(msgpack.unpack(msgpack.pack(null))); - test.done(); - }, - 'test for negative decimal number' : function (test) { - test.expect(2); - test.deepEqual(-1243.111, msgpack.unpack(msgpack.pack(-1243.111))); - test.isNumber(msgpack.unpack(msgpack.pack(-1243.111))); - test.done(); - }, - 'test for negative number' : function (test) { - test.expect(2); - test.deepEqual(-123, msgpack.unpack(msgpack.pack(-123))); - test.isNumber(msgpack.unpack(msgpack.pack(-123))); - test.done(); - }, - 'test for true' : function (test) { - test.expect(2); - test.deepEqual(true, msgpack.unpack(msgpack.pack(true))); - test.isBoolean(msgpack.unpack(msgpack.pack(true))); - test.done(); - }, - 'test for false' : function (test) { - test.expect(2); - test.deepEqual(false, msgpack.unpack(msgpack.pack(false))); - test.isBoolean(msgpack.unpack(msgpack.pack(false))); - test.done(); - }, - 'test for numeric array' : function (test) { - test.expect(2); - test.deepEqual([1,2,3], msgpack.unpack(msgpack.pack([1,2,3]))); - test.isArray(msgpack.unpack(msgpack.pack([1,2,3]))); - test.done(); - }, - 'test for mixed type array' : function (test) { - test.expect(2); - test.deepEqual( - [1, 'abc', false, null], - msgpack.unpack(msgpack.pack([1, 'abc', false, null])) - ); - test.isArray(msgpack.unpack(msgpack.pack([1,2,3]))); - test.done(); - }, - 'test for object' : function (test) { - test.expect(2); - var object = {'a' : [1, 2, 3], 'b' : 'cdef', 'c' : {'nuts' : 'qqq'}}; - test.deepEqual(object, msgpack.unpack(msgpack.pack(object))); - test.isObject(msgpack.unpack(msgpack.pack(object))); - test.done(); - }, - 'test for 2^31 negative' : function (test) { - test.expect(2); - test.deepEqual( - 0 - Math.pow(2,31) - 1, - msgpack.unpack(msgpack.pack(0 - Math.pow(2,31) - 1)) - ); - test.isNumber(msgpack.unpack(msgpack.pack(0 - Math.pow(2,31) - 1))); - test.done(); - }, - 'test for 2^40 negative' : function (test) { - test.expect(2); - test.deepEqual( - 0 - Math.pow(2,40) - 1, - msgpack.unpack(msgpack.pack(0 - Math.pow(2,40) - 1)) - ); - test.isNumber(msgpack.unpack(msgpack.pack(0 - Math.pow(2,40) - 1))); - test.done(); - }, - 'test for 2^31' : function (test) { - test.expect(2); - test.deepEqual( - Math.pow(2,31) + 1, - msgpack.unpack(msgpack.pack(Math.pow(2,31) + 1)) - ); - test.isNumber(msgpack.unpack(msgpack.pack(Math.pow(2,31) + 1))); - test.done(); - }, - 'test for 2^40' : function (test) { - test.expect(2); - test.deepEqual( - Math.pow(2,40) + 1, - msgpack.unpack(msgpack.pack(Math.pow(2,40) + 1)) - ); - test.isNumber(msgpack.unpack(msgpack.pack(Math.pow(2,40) + 1))); - test.done(); - }, - 'test number approaching 2^64' : function (test) { - test.expect(2); - test.deepEqual( - 123456782345245, - msgpack.unpack(msgpack.pack(123456782345245)) - ); - test.isNumber(msgpack.unpack(msgpack.pack(123456782345245))); - test.done(); - }, - 'make sure dates are handled properly' : function (test) { - test.expect(2); - var date = new Date(); - var dateObj = { d : date }; - test.deepEqual( - { d : date.toISOString() }, - msgpack.unpack(msgpack.pack(dateObj)) - ); - test.isObject(msgpack.unpack(msgpack.pack(dateObj))); - test.done(); - }, - 'test for circular reference' : function (test) { - test.expect(1); - var a = [1, 2, 3, 4]; - a.push(a); - this.testCircular(a, test); - test.done(); - }, - 'test for circular reference in objects' : function (test) { - test.expect(1); - var d = {}; - d.qqq = d; - this.testCircular(d, test); - test.done(); - }, - 'test for not catching multiple non-circular references' : function (test) { - test.expect(2); - var e = {}; - test.deepEqual( - { a : e, b : e }, - msgpack.unpack(msgpack.pack({ a : e, b : e })) - ); - test.isObject(msgpack.unpack(msgpack.pack({ a : e, b : e }))); - test.done(); - }, - 'unpacking a buffer with extra data doesn\'t lose the extra data' : function (test) { - test.expect(4); - // Object to test with - var o = [1, 2, 3]; - - // Create two buffers full of packed data, 'b' and 'bb', with the latter - // containing 3 extra bytes - var b = msgpack.pack(o); - var bb = new Buffer(b.length + 3); - b.copy(bb, 0, 0, b.length); - - // Expect no remaining bytes when unpacking 'b' - test.deepEqual(msgpack.unpack(b), o); - test.deepEqual(msgpack.unpack.bytes_remaining, 0); - - // Expect 3 remaining bytes when unpacking 'bb' - test.deepEqual(msgpack.unpack(bb), o); - test.equal(msgpack.unpack.bytes_remaining, 3); - - test.done(); - }, - 'circular reference marking algorithm doesn\'t false positive' : function (test) { - test.expect(1); - try { - var d = {}; - for (var i = 0; i < 10; i++) { - msgpack.pack(d); - } - test.ok(true, 'all clear'); - } catch (e) { - test.ok(false, e.message); - } - test.done(); - }, - 'test toJSON compatibility' : function (test) { - var expect = { msg: 'hello world' }; - var subject = { toJSON: function() { return expect; }}; - test.expect(1); - test.deepEqual(expect, msgpack.unpack(msgpack.pack(subject))); - test.done(); - }, - 'test toJSON compatibility for multiple args' : function (test) { - var expect = { msg: 'hello world' }; - var subject = { toJSON: function() { return expect; }}; - var subject1 = { toJSON: function() { msg: 'goodbye world' }}; - test.expect(1); - test.deepEqual(expect, msgpack.unpack(msgpack.pack(subject, subject1))); - test.done(); - }, - 'test toJSON compatibility for nested toJSON' : function (test) { - var expect = { msg: 'hello world' }; - var subject = { - toJSON: function() { - return [ - expect, - { - toJSON: function() { - return expect; - } - } - ]; - } - }; - test.expect(1); - test.deepEqual([expect, expect], msgpack.unpack(msgpack.pack(subject))); - test.done(); - }, - 'test toJSON compatibility with prototype' : function (test) { - var expect = { msg: 'hello world' }; - var subject = { __proto__: { toJSON: function() { return expect; }}}; - test.expect(1); - test.deepEqual(expect, msgpack.unpack(msgpack.pack(subject))); - test.done(); - } -}; diff --git a/test/msgpack.test.js b/test/msgpack.test.js new file mode 100644 index 0000000..1fef130 --- /dev/null +++ b/test/msgpack.test.js @@ -0,0 +1,325 @@ +'use strict'; + +const { describe, it } = require('node:test'); +const assert = require('node:assert/strict'); +const { EventEmitter } = require('events'); +const net = require('net'); +const path = require('path'); +const { execFileSync } = require('child_process'); +const msgpack = require('../lib/msgpack'); +const stub = require('./fixtures/stub'); + +function roundTrip(value) { + const packed = msgpack.pack(value); + assert.ok(Buffer.isBuffer(packed)); + return msgpack.unpack(packed); +} + +describe('msgpack pack/unpack', () => { + it('round-trips primitive and composite values', () => { + const o = [ + 'string', + true, + false, + null, + 0, + 1, + -1, + 1.1, + -1.1, + 2, + 20, + 200, + 2000, + 20000, + 200000, + 2000000, + 20000000, + 200000000, + 2000000000, + -2, + -20, + -200, + -2000, + -20000, + -200000, + -2000000, + -20000000, + -200000000, + -2000000000, + { foo: 'bar', baz: 'quux' }, + [1, 2, 3, 4], + Buffer.from([0, 1, 2, 3, 4, 5, 6, 7]), + ]; + const got = roundTrip(o); + assert.deepEqual(got, o); + assert.ok(Buffer.isBuffer(got[got.length - 1])); + }); + + it('packs a top-level Buffer as bin, not a toJSON map', () => { + const buf = Buffer.from([1, 2, 3]); + const packed = msgpack.pack(buf); + assert.ok(Buffer.isBuffer(packed)); + /* bin 8 for a 3-byte payload: 0xc4 len data, not fixstr and not a map. */ + assert.equal(packed[0], 0xc4); + const got = msgpack.unpack(packed); + assert.ok(Buffer.isBuffer(got)); + assert.deepEqual([...got], [1, 2, 3]); + }); + + it('unpacks a 7-bit integer', () => { + assert.equal(msgpack.unpack(Buffer.from([0x05])), 5); + }); + + it('returns null for a truncated object', () => { + const packed = msgpack.pack({ a: 'abc', b: 1, c: [1, 2, 3] }); + const truncated = packed.subarray(0, packed.length - 1); + assert.equal(msgpack.unpack(truncated), null); + }); + + it('uses toJSON when packing', () => { + const obj = { a: 1 }; + obj.toJSON = () => ({ b: 2 }); + assert.deepEqual(msgpack.unpack(msgpack.pack(obj)), { b: 2 }); + }); + + it('uses toJSON on nested objects too', () => { + const o = { inner: { toJSON: () => ({ b: 2 }) } }; + assert.deepEqual(msgpack.unpack(msgpack.pack(o)), { inner: { b: 2 } }); + }); + + it('packs a top-level Date as its ISO string', () => { + const d = new Date('2000-06-13T00:00:00.000Z'); + assert.equal(msgpack.unpack(msgpack.pack(d)), '2000-06-13T00:00:00.000Z'); + }); + + it('packs a nested Date as its ISO string', () => { + const d = new Date('2000-06-13T00:00:00.000Z'); + assert.deepEqual(msgpack.unpack(msgpack.pack({ d })), { + d: '2000-06-13T00:00:00.000Z', + }); + }); + + it('packs numeric keys as well as string keys', () => { + assert.deepEqual(msgpack.unpack(msgpack.pack({ 1: 'a', b: 'c' })), { + 1: 'a', + b: 'c', + }); + }); + + it('does not drop a user key named _msgpack_stack', () => { + /* Cycle marks are V8 private symbols now, so this is an ordinary key. */ + assert.deepEqual(msgpack.unpack(msgpack.pack({ _msgpack_stack: 1, b: 2 })), { + _msgpack_stack: 1, + b: 2, + }); + }); + + it('throws on circular object and array', () => { + const o = {}; + o.a = o; + assert.throws(() => msgpack.pack(o), /circular/); + + const a = []; + a.push(a); + assert.throws(() => msgpack.pack(a), /circular/); + }); +}); + +describe('msgpack.Stream', () => { + it('sends a packed message through write', () => { + const s = new EventEmitter(); + s.writable = true; + s.write = stub(); + const ms = new msgpack.Stream(s); + ms.send('hello'); + assert.equal(s.write.called, true); + assert.equal(s.write.args.length, 1); + assert.deepEqual(msgpack.unpack(s.write.args[0]), 'hello'); + }); + + it('passes extra send arguments to write', () => { + const s = new EventEmitter(); + s.writable = true; + s.write = stub(); + const ms = new msgpack.Stream(s); + ms.send('hello', 1, 2, 3); + assert.equal(s.write.called, true); + assert.equal(s.write.args.length, 4); + assert.deepEqual(msgpack.unpack(s.write.args[0]), 'hello'); + assert.deepEqual(Array.prototype.slice.call(s.write.args, 1), [1, 2, 3]); + }); + + it('emits msg for a complete packet', () => { + const s = new EventEmitter(); + const ms = new msgpack.Stream(s); + ms.addListener('msg', stub()); + s.emit('data', msgpack.pack('hello')); + assert.equal(ms.listeners('msg')[0].called, true); + assert.equal(ms.listeners('msg')[0].args.length, 1); + assert.equal(ms.listeners('msg')[0].args[0], 'hello'); + }); + + it('parses two messages split across data events', () => { + const s = new EventEmitter(); + const ms = new msgpack.Stream(s); + ms.addListener('msg', stub()); + const packed = msgpack.pack('hello'); + s.emit('data', packed.subarray(0, packed.length - 1)); + assert.equal(ms.listeners('msg')[0].called, false); + s.emit('data', packed.subarray(packed.length - 1)); + assert.equal(ms.listeners('msg')[0].called, true); + assert.equal(ms.listeners('msg')[0].args.length, 1); + assert.equal(ms.listeners('msg')[0].args[0], 'hello'); + }); + + it('emits msg for a packed zero', () => { + /* msgpack-node#44: the loop tested `msg === null` against a falsy check, + * so a packed integer 0 was swallowed as "incomplete". */ + const s = new EventEmitter(); + const ms = new msgpack.Stream(s); + const msgs = []; + ms.addListener('msg', (m) => msgs.push(m)); + + s.emit('data', msgpack.pack(0)); + + assert.equal(msgs.length, 1); + assert.equal(typeof msgs[0], 'number'); + assert.equal(msgs[0], 0); + + /* And a 0 framed alongside neighbours still advances the buffer. */ + s.emit('data', Buffer.concat([msgpack.pack(0), msgpack.pack('after')])); + assert.deepEqual(msgs, [0, 0, 'after']); + }); + + it('emits msg for a packed null', () => { + /* A decoded nil is a message, not an incomplete buffer. */ + const s = new EventEmitter(); + const ms = new msgpack.Stream(s); + const msgs = []; + ms.addListener('msg', (m) => msgs.push(m)); + s.emit('data', msgpack.pack(null)); + s.emit('data', Buffer.concat([msgpack.pack(null), msgpack.pack('after')])); + assert.deepEqual(msgs, [null, null, 'after']); + }); + + it('waits on a truncated payload without emitting', () => { + const s = new EventEmitter(); + const ms = new msgpack.Stream(s); + ms.addListener('msg', stub()); + const packed = msgpack.pack({ a: 'abc', b: [1, 2, 3] }); + s.emit('data', packed.subarray(0, packed.length - 1)); + assert.equal(ms.listeners('msg')[0].called, false); + }); + + it('emits error instead of throwing when unpack fails', () => { + /* array32 header claiming 0xff000000 elements: unpack throws, and the + * data listener must not turn that into an uncaughtException. */ + const s = new EventEmitter(); + const ms = new msgpack.Stream(s); + const errors = []; + ms.addListener('error', (e) => errors.push(e)); + ms.addListener('msg', stub()); + + s.emit('data', Buffer.from([0xdd, 0xff, 0x00, 0x00, 0x00])); + + assert.equal(errors.length, 1); + assert.match(errors[0].message, /limit exceeded/); + assert.equal(ms.listeners('msg')[0].called, false); + /* The bomb is dropped, not retried: a following good packet parses. */ + s.emit('data', msgpack.pack('ok')); + assert.equal(ms.listeners('msg')[0].args[0], 'ok'); + assert.equal(errors.length, 1); + }); + + it('delivers both frames when a msg listener calls unpack', () => { + /* bytes_remaining is a single C++ global: a listener that unpacks + * anything overwrites the value this loop needs to advance self.buf. */ + const s = new EventEmitter(); + const ms = new msgpack.Stream(s); + const msgs = []; + ms.addListener('msg', (m) => { + msgs.push(m); + msgpack.unpack(Buffer.from([0x02])); + }); + + s.emit('data', Buffer.concat([msgpack.pack({ n: 1 }), msgpack.pack({ n: 2 })])); + + assert.deepEqual(msgs, [{ n: 1 }, { n: 2 }]); + }); + + it('does not re-emit a frame whose msg listener threw', () => { + /* Emitting before advancing self.buf left the frame queued, so the next + * data event replayed it: seen became ['one', 'one', 'two', 'three']. */ + const s = new EventEmitter(); + const ms = new msgpack.Stream(s); + const seen = []; + let first = true; + ms.addListener('msg', (m) => { + seen.push(m); + if (first) { + first = false; + throw new Error('listener blew up'); + } + }); + + assert.throws(() => s.emit('data', msgpack.pack('one')), /listener blew up/); + s.emit('data', Buffer.concat([msgpack.pack('two'), msgpack.pack('three')])); + + assert.deepEqual(seen, ['one', 'two', 'three']); + }); + + it('round-trips over a TCP socket', (t, done) => { + const server = net.createServer((c) => { + c.write(msgpack.pack('hello ')); + setTimeout(() => { + c.end(msgpack.pack('world')); + }, 50); + }); + + server.listen(0, '127.0.0.1', () => { + const addr = server.address(); + const client = net.createConnection(addr.port, addr.address); + const msgs = []; + client.on('connect', () => { + const ms = new msgpack.Stream(client); + ms.addListener('msg', (m) => { + msgs.push(m); + if (msgs.length === 2) { + assert.deepEqual(msgs, ['hello ', 'world']); + server.close(); + done(); + } + }); + }); + }); + }); +}); + +describe('bin scripts', () => { + const bin = (name) => path.join(__dirname, '..', 'bin', name); + const run = (name, input) => + execFileSync(process.execPath, [bin(name)], { input, maxBuffer: 1 << 20 }); + + it('msgpack2json writes JSON for a packed value', () => { + const out = run('msgpack2json', msgpack.pack({ a: 1, b: [2, 3] })); + assert.deepEqual(JSON.parse(out.toString('utf8')), { a: 1, b: [2, 3] }); + }); + + it('msgpack2json writes one line per concatenated message', () => { + const input = Buffer.concat([msgpack.pack('one'), msgpack.pack('two')]); + const lines = run('msgpack2json', input).toString('utf8').trim().split('\n'); + assert.deepEqual(lines, ['"one"', '"two"']); + }); + + it('json2msgpack writes MessagePack for JSON on stdin', () => { + const out = run('json2msgpack', '{"a":1,"b":[2,3]}'); + assert.deepEqual(msgpack.unpack(out), { a: 1, b: [2, 3] }); + }); + + it('json2msgpack and msgpack2json round-trip', () => { + const packed = run('json2msgpack', '{"hello":"world"}'); + const json = run('msgpack2json', packed).toString('utf8'); + assert.deepEqual(JSON.parse(json), { hello: 'world' }); + }); +}); diff --git a/test/regression.js b/test/regression.js deleted file mode 100644 index 3c0a10b..0000000 --- a/test/regression.js +++ /dev/null @@ -1,41 +0,0 @@ -var fs = require('fs'), - msgpack = require("../lib/msgpack"), - stub = require("./fixtures/stub"); - -function _set_up(callback) { - this.backup = {}; - callback(); -} - -function _tear_down(callback) { - callback(); -} - -exports.regression = { - setUp : _set_up, - tearDown : _tear_down, - 'https://github.com/pgriess/node-msgpack/issues/15' : function (test) { - var obj = {a:123}; - var fileName = './packed-data'; - var packedObj = msgpack.pack(obj); - test.expect(2); - fs.writeFileSync(fileName, packedObj); - packedObj2 = fs.readFileSync(fileName); - test.deepEqual(packedObj, packedObj2); - var unpackedObj = msgpack.unpack(packedObj2); // crash - test.deepEqual(obj, unpackedObj); - fs.unlinkSync(fileName); - test.done(); - }, - 'https://github.com/msgpack/msgpack-node/issues/5' : function (test) { - var originalArray = ['one', 'two']; - var packedArray = msgpack.pack(originalArray); - var buffer = new Buffer(packedArray.toString('binary'), 'binary'); - test.expect(3); - unpackedArray = msgpack.unpack(buffer); - test.isArray(originalArray); - test.isArray(unpackedArray); - test.deepEqual(originalArray, unpackedArray); - test.done(); - } -}; diff --git a/test/regression.test.js b/test/regression.test.js new file mode 100644 index 0000000..d272240 --- /dev/null +++ b/test/regression.test.js @@ -0,0 +1,54 @@ +'use strict'; + +const { describe, it } = require('node:test'); +const assert = require('node:assert/strict'); +const msgpack = require('../lib/msgpack'); + +describe('regressions', () => { + it('unpacks a 7-bit integer from a larger buffer (bytes_remaining)', () => { + const buf = Buffer.from([0x05, 0x00]); + assert.equal(msgpack.unpack(buf), 5); + assert.equal(msgpack.unpack.bytes_remaining, 1); + }); + + it('rejects Date without toJSON as a packable object (no crash)', () => { + /* Dates pack natively as their ISO string. */ + const packed = msgpack.pack(new Date('2000-06-13T00:00:00.000Z')); + assert.equal(typeof msgpack.unpack(packed), 'string'); + }); + + it('packs out-of-range integral doubles as doubles', () => { + /* 1e30 is integral but does not fit uint64; the cast was UB and put + * 2^64-1 on the wire. */ + const big = msgpack.unpack(msgpack.pack(1e30)); + assert.equal(typeof big, 'number'); + assert.ok(Number.isFinite(big)); + assert.equal(big, 1e30); + + const negBig = msgpack.unpack(msgpack.pack(-1e30)); + assert.ok(Number.isFinite(negBig)); + assert.equal(negBig, -1e30); + }); + + it('still packs integers at the edges of the integer path', () => { + for (const n of [0, 1, -1, 2 ** 53, -(2 ** 53), 2 ** 63, -(2 ** 63)]) { + assert.equal(msgpack.unpack(msgpack.pack(n)), n); + } + }); + + it('unpacks a map written by Python msgpack (msgpack-node#10)', () => { + /* Latin-1 wire bytes straight out of python-msgpack: fixmap of 5 with a + * bool, two fixstrs, a uint8 and a bin8 payload. */ + const wire = '\x85\xa8Coalesce\xc3\xa5Event\xa4user\xa5LTime\xcc\x01' + + '\xa4Name\xa4test\xa7Payload\xc4\x03foo'; + const unpacked = msgpack.unpack(Buffer.from(wire, 'latin1')); + + assert.equal(unpacked.Coalesce, true); + assert.equal(unpacked.Event, 'user'); + assert.equal(unpacked.LTime, 1); + assert.equal(unpacked.Name, 'test'); + assert.ok(Buffer.isBuffer(unpacked.Payload)); + assert.deepEqual(unpacked.Payload, Buffer.from('foo')); + assert.equal(msgpack.unpack.bytes_remaining, 0); + }); +}); diff --git a/test/security.test.js b/test/security.test.js new file mode 100644 index 0000000..efa6a30 --- /dev/null +++ b/test/security.test.js @@ -0,0 +1,209 @@ +'use strict'; + +const { describe, it } = require('node:test'); +const assert = require('node:assert/strict'); +const msgpack = require('../lib/msgpack'); + +function assertThrowsUnpack(buf, re) { + assert.throws(() => msgpack.unpack(buf), re); +} + +describe('unpack DoS limits', () => { + it('rejects array32 header dd ff 00 00 00 without allocating', { timeout: 5000 }, () => { + const buf = Buffer.from([0xdd, 0xff, 0x00, 0x00, 0x00]); + assertThrowsUnpack(buf, /limit exceeded/); + }); + + it('rejects map32 header df ff 00 00 00', { timeout: 5000 }, () => { + const buf = Buffer.from([0xdf, 0xff, 0x00, 0x00, 0x00]); + assertThrowsUnpack(buf, /limit exceeded/); + }); + + it('rejects str32 claiming 32MiB+1 bytes', { timeout: 5000 }, () => { + const buf = Buffer.from([0xdb, 0x02, 0x00, 0x00, 0x01]); + assertThrowsUnpack(buf, /limit exceeded/); + }); + + it('rejects bin32 claiming 32MiB+1 bytes', { timeout: 5000 }, () => { + const buf = Buffer.from([0xc6, 0x02, 0x00, 0x00, 0x01]); + assertThrowsUnpack(buf, /limit exceeded/); + }); + + it('returns null for a truncated but modest array16', () => { + /* array16 of 3 elements, no payload — incomplete, not a bomb. */ + const buf = Buffer.from([0xdc, 0x00, 0x03]); + assert.equal(msgpack.unpack(buf), null); + }); + + it('round-trips a legitimately large array', () => { + const n = 10000; + const a = new Array(n); + for (let i = 0; i < n; i++) a[i] = i; + assert.deepEqual(msgpack.unpack(msgpack.pack(a)), a); + }); +}); + +describe('pack throw paths do not leak (nodejs/node#25686)', () => { + it('survives many pack failures without crashing', () => { + for (let i = 0; i < 20000; i++) { + assert.throws(() => msgpack.pack([function () {}])); + const o = {}; + o.self = o; + assert.throws(() => msgpack.pack(o)); + } + /* If the sbuffer leaked on throw, 20k failures of even small objects + * would grow RSS dramatically. A follow-up pack still works. */ + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); +}); + +function nestArrays(n) { + let a = 1; + for (let i = 0; i < n; i++) a = [a]; + return a; +} + +describe('pack recursion depth', () => { + it('throws instead of crashing on 8000 nested arrays', () => { + /* Before the cap this recursed 8000 frames deep in C++ and SIGSEGVed. */ + assert.throws(() => msgpack.pack(nestArrays(8000)), /Cowardly refusing/); + /* Process is still alive and usable. */ + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); + + it('throws instead of crashing on 8000 nested objects', () => { + let o = 1; + for (let i = 0; i < 8000; i++) o = { o }; + assert.throws(() => msgpack.pack(o), /Cowardly refusing/); + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); + + it('still round-trips allowed nesting depths', () => { + for (const n of [1, 32, 100]) { + assert.deepEqual(msgpack.unpack(msgpack.pack(nestArrays(n))), nestArrays(n)); + } + }); +}); + +describe('unpack depth vs the C embed stack', () => { + it('round-trips 32 levels of nesting', () => { + /* msgpack-c defaults MSGPACK_EMBED_STACK_SIZE to 32, which made this + * fail with a generic parse error; the vendored build now uses 512. */ + const a = nestArrays(32); + assert.deepEqual(msgpack.unpack(msgpack.pack(a)), a); + }); + + it('round-trips the deepest packable nesting', () => { + /* Pack allows a value at depth 512, so the deepest array holding a + * scalar is 511 levels; unpack accepts 511 containers as well. */ + const a = nestArrays(511); + assert.deepEqual(msgpack.unpack(msgpack.pack(a)), a); + assert.throws(() => msgpack.pack(nestArrays(512)), /Cowardly refusing/); + }); + + it('rejects an over-deep buffer with the limit error', () => { + /* Hand-built: N fixarray-of-1 headers around a single fixint. 511 + * containers is the working maximum, 512 is over the limit. */ + const deep = (n) => Buffer.concat([Buffer.alloc(n, 0x91), Buffer.from([0x01])]); + assert.notEqual(msgpack.unpack(deep(511)), null); + assert.throws(() => msgpack.unpack(deep(512)), /limit exceeded/); + assert.throws(() => msgpack.unpack(deep(1000)), /limit exceeded/); + }); +}); + +describe('unpack prototype pollution', () => { + /* Raw wire, not msgpack.pack(): a map whose only key is the string + * "__proto__". Nan::Set walked the inherited __proto__ setter and swapped + * the decoded object's prototype instead of storing a property. */ + const protoWire = (valueBytes) => + Buffer.concat([ + Buffer.from([0x81]), + Buffer.from([0xa9]), + Buffer.from('__proto__', 'utf8'), + valueBytes, + ]); + + it('makes an object-valued __proto__ key an own property', () => { + const wire = Buffer.from('81a95f5f70726f746f5f5f81a7697341646d696ec3', 'hex'); + const decoded = msgpack.unpack(wire); + + assert.equal(Object.getPrototypeOf(decoded), Object.prototype); + assert.notEqual(decoded.isAdmin, true); + assert.deepEqual(Object.keys(decoded), ['__proto__']); + assert.deepEqual( + Object.getOwnPropertyDescriptor(decoded, '__proto__'), + { value: { isAdmin: true }, writable: true, enumerable: true, configurable: true } + ); + /* Nothing leaked onto Object.prototype either. */ + assert.equal({}.isAdmin, undefined); + }); + + it('makes a scalar __proto__ key an own property', () => { + const decoded = msgpack.unpack(protoWire(Buffer.from([0x05]))); + + assert.equal(Object.getPrototypeOf(decoded), Object.prototype); + assert.deepEqual(Object.keys(decoded), ['__proto__']); + assert.equal(Object.getOwnPropertyDescriptor(decoded, '__proto__').value, 5); + }); + + it('makes a nil __proto__ key an own property without nulling the prototype', () => { + /* `obj.__proto__ = null` via Set would have left a prototype-less object + * with no hasOwnProperty. */ + const decoded = msgpack.unpack(protoWire(Buffer.from([0xc0]))); + + assert.equal(Object.getPrototypeOf(decoded), Object.prototype); + assert.deepEqual(Object.keys(decoded), ['__proto__']); + assert.equal(Object.getOwnPropertyDescriptor(decoded, '__proto__').value, null); + assert.equal(decoded.hasOwnProperty('__proto__'), true); + }); + + it('still round-trips ordinary keys alongside __proto__', () => { + const wire = Buffer.concat([ + Buffer.from([0x82]), + msgpack.pack('__proto__'), + msgpack.pack({ isAdmin: true }), + msgpack.pack('a'), + msgpack.pack(1), + ]); + const decoded = msgpack.unpack(wire); + + assert.deepEqual(Object.keys(decoded), ['__proto__', 'a']); + assert.equal(decoded.a, 1); + assert.equal(Object.getPrototypeOf(decoded), Object.prototype); + }); +}); + +describe('pack does not abort on a throwing property read', () => { + /* Nan::Get(...).ToLocalChecked() on an empty MaybeLocal killed the process + * with "FATAL ERROR: v8::ToLocalChecked Empty MaybeLocal". */ + it('throws a catchable error for a throwing getter', () => { + assert.throws(() => msgpack.pack({ get a() { throw new Error('x'); } }), /^Error: x$/); + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); + + it('throws a catchable error for a throwing Proxy ownKeys trap', () => { + const p = new Proxy({}, { ownKeys() { throw new Error('x'); } }); + assert.throws(() => msgpack.pack(p), /^Error: x$/); + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); + + it('throws a catchable error for a throwing Proxy get trap', () => { + const p = new Proxy({ a: 1 }, { get() { throw new Error('x'); } }); + assert.throws(() => msgpack.pack(p), /^Error: x$/); + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); + + it('throws a catchable error for a throwing array element getter', () => { + const a = [1]; + Object.defineProperty(a, '0', { get() { throw new Error('x'); } }); + assert.throws(() => msgpack.pack(a), /^Error: x$/); + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); + + it('survives repeated throwing reads', () => { + for (let i = 0; i < 1000; i++) { + assert.throws(() => msgpack.pack({ get a() { throw new Error('x'); } })); + } + assert.equal(msgpack.unpack(msgpack.pack('ok')), 'ok'); + }); +}); diff --git a/test/worker.test.js b/test/worker.test.js new file mode 100644 index 0000000..aa60cde --- /dev/null +++ b/test/worker.test.js @@ -0,0 +1,170 @@ +'use strict'; + +const { describe, it } = require('node:test'); +const assert = require('node:assert/strict'); +const path = require('path'); +const { Worker } = require('worker_threads'); + +/* Load the addon on the main thread first: the regression only shows up on + * the *second* load of msgpackBinding.node, i.e. inside the worker. */ +const msgpack = require('../'); +const binding = require('../build/Release/msgpackBinding'); + +const WORKER = path.join(__dirname, 'fixtures', 'msgpack-worker.js'); + +function runWorker(op, extra, onReady) { + return new Promise((resolve, reject) => { + const workerData = Object.assign({ op: op }, extra); + const worker = new Worker(WORKER, { workerData: workerData }); + let message; + let settled = false; + worker.on('message', (m) => { + /* A {ready:true} note means the worker has loaded the addon and is + * parked on the start gate; the real result comes later. */ + if (m && m.ready === true) { + if (onReady) onReady(worker); + return; + } + message = m; + }); + worker.once('error', (err) => { + settled = true; + reject(err); + }); + worker.once('exit', (code) => { + if (settled) return; + if (code !== 0) return reject(new Error('worker exited with code ' + code)); + resolve(message); + }); + }); +} + +describe('worker_threads', () => { + it('loads the addon inside a worker and round-trips values', async () => { + const result = await runWorker('roundtrip'); + assert.deepEqual(result.keys, ['a', 'b']); + assert.equal(result.a, 1); + assert.equal(result.bIsBuffer, true, 'bin stays a Buffer in the worker'); + assert.equal(result.b, 'hi'); + }); + + it('still detects cycles inside a worker', async () => { + const result = await runWorker('cycle'); + assert.equal(result.threw, true); + assert.match(result.message, /circular/); + }); + + it('leaves the main thread working after a worker has loaded the addon', async () => { + await runWorker('roundtrip'); + + const value = { a: 1, b: Buffer.from('hi'), c: [1, 'two', null] }; + const unpacked = msgpack.unpack(msgpack.pack(value)); + assert.equal(unpacked.a, 1); + assert.ok(Buffer.isBuffer(unpacked.b)); + assert.equal(unpacked.b.toString('latin1'), 'hi'); + assert.deepEqual(unpacked.c, [1, 'two', null]); + + /* Cycle detection uses a process-wide private key; check it survived the + * worker's module init. */ + const cyclic = {}; + cyclic.self = cyclic; + assert.throws(() => msgpack.pack(cyclic), /circular/); + }); + + it('does not let a worker unpack clobber the main thread bytes_remaining', async () => { + const buf = Buffer.concat([msgpack.pack(1), Buffer.alloc(3)]); + assert.equal(msgpack.unpack(buf), 1); + assert.equal(msgpack.unpack.bytes_remaining, 3); + + const result = await runWorker('unpack-remaining'); + assert.equal(result.value, 'worker'); + assert.equal(result.bytesRemaining, 7); + + /* The JS-level snapshot is per-thread by construction; the native counter + * behind it is a single global unless it is thread_local. */ + assert.equal(msgpack.unpack.bytes_remaining, 3); + assert.equal(binding.bytesRemaining(), 3); + }); + + it('packs on several workers concurrently with the main thread', async () => { + const WORKERS = 4; + const ITERATIONS = 4000; + + /* gate[0] flips to 1 when every worker has loaded the addon, releasing + * all of them at once so their packing really does overlap this thread's. */ + const gate = new Int32Array(new SharedArrayBuffer(4)); + + let ready = 0; + let releaseAll; + const allReady = new Promise((resolve) => { releaseAll = resolve; }); + + const running = []; + for (let id = 1; id <= WORKERS; id++) { + running.push(runWorker('concurrent-pack', { id: id, iterations: ITERATIONS, gate: gate.buffer }, () => { + if (++ready === WORKERS) releaseAll(); + })); + } + + /* If a worker dies before signalling ready, surface that error instead of + * waiting on a barrier that will never be reached. */ + await Promise.race([allReady, Promise.all(running)]); + + Atomics.store(gate, 0, 1); + Atomics.notify(gate, 0); + + /* Pack on the main thread while the workers are packing. The pack buffer + * pool is thread_local, so nobody should ever see another thread's bytes. */ + for (let i = 0; i < ITERATIONS; i++) { + const value = { + id: 0, + i: i, + tag: 'main-' + i, + blob: Buffer.from('m'.repeat(1 + (i % 53))), + list: [i, 'main' + i, null, false], + nested: { depth: { value: -1 - i } } + }; + const unpacked = msgpack.unpack(msgpack.pack(value)); + assert.equal(unpacked.id, 0); + assert.equal(unpacked.i, i); + assert.equal(unpacked.tag, 'main-' + i); + assert.equal(unpacked.blob.toString('latin1'), value.blob.toString('latin1')); + assert.deepEqual(unpacked.list, value.list); + assert.equal(unpacked.nested.depth.value, -1 - i); + } + + const results = await Promise.all(running); + assert.equal(results.length, WORKERS); + results.forEach((result, index) => { + assert.ok(result, 'worker ' + (index + 1) + ' posted a result'); + assert.equal(result.ok, true); + assert.equal(result.id, index + 1); + assert.equal(result.iterations, ITERATIONS); + }); + + /* The main thread keeps working once the workers are gone: each worker's + * pool was freed with its thread, not handed back to this one. */ + assert.deepEqual(msgpack.unpack(msgpack.pack({ after: [1, 2, 3] })), { after: [1, 2, 3] }); + }); + + it('reuses the pack buffer pool across many sequential packs', () => { + /* The first pack mallocs its sbuffer and hands the memory to Node + * (NewBuffer); every later one takes a pooled sbuffer and copies out + * (CopyBuffer). Both paths have to produce identical bytes. */ + const value = { a: 1, b: Buffer.from('hi'), c: [1, 'two', null], d: { e: -7 } }; + const first = msgpack.pack(value); + for (let i = 0; i < 2000; i++) { + const packed = msgpack.pack(value); + assert.ok(packed.equals(first), 'pack #' + i + ' differs from the first pack'); + const unpacked = msgpack.unpack(packed); + assert.equal(unpacked.a, 1); + assert.equal(unpacked.b.toString('latin1'), 'hi'); + assert.deepEqual(unpacked.c, [1, 'two', null]); + assert.equal(unpacked.d.e, -7); + } + + /* A pooled sbuffer is reused after a much larger pack, so a stale size or + * leftover bytes would show up here. */ + msgpack.pack({ big: Buffer.alloc(200000, 0x41) }); + assert.ok(msgpack.pack(value).equals(first), 'pack after a large pack differs'); + }); +});