From d4150227a78ab83b85e27cc4999bd61376a76896 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Sun, 15 Sep 2013 16:52:34 -0700 Subject: [PATCH 01/43] Initial wrapping of kj/async Promises and EventLoop --- capnp/async.h | 25 +++++++++++++++++++++ capnp/async.pyx | 54 +++++++++++++++++++++++++++++++++++++++++++++ capnp/asyncHelper.h | 25 +++++++++++++++++++++ capnp/async_cpp.pxd | 31 ++++++++++++++++++++++++++ 4 files changed, 135 insertions(+) create mode 100644 capnp/async.h create mode 100644 capnp/async.pyx create mode 100644 capnp/asyncHelper.h create mode 100644 capnp/async_cpp.pxd diff --git a/capnp/async.h b/capnp/async.h new file mode 100644 index 0000000..9b28e5a --- /dev/null +++ b/capnp/async.h @@ -0,0 +1,25 @@ +#ifndef __PYX_HAVE__capnp__async +#define __PYX_HAVE__capnp__async + + +#ifndef __PYX_HAVE_API__capnp__async + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +__PYX_EXTERN_C DL_IMPORT(PyObject) *wrap_kj_exception( ::kj::Exception &); + +#endif /* !__PYX_HAVE_API__capnp__async */ + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initasync(void); +#else +PyMODINIT_FUNC PyInit_async(void); +#endif + +#endif /* !__PYX_HAVE__capnp__async */ diff --git a/capnp/async.pyx b/capnp/async.pyx new file mode 100644 index 0000000..5c1b980 --- /dev/null +++ b/capnp/async.pyx @@ -0,0 +1,54 @@ +# capnp.pyx +# distutils: language = c++ +# distutils: extra_compile_args = --std=c++11 -fpermissive +# distutils: libraries = kj +# cython: c_string_type = str +# cython: c_string_encoding = default +# cython: embedsignature = True + +cimport cython +cimport async_cpp as async +from cpython.ref cimport PyObject, Py_INCREF, Py_DECREF +from cython.operator cimport dereference as deref + +cdef extern from "" namespace "std": + async.PyPromise movePromise"std::move"(async.PyPromise) + +# This is a really weird function. By making it public, we'll be able to call it from asyncHelper.h +cdef public object wrap_kj_exception(async.Exception & exception): + return None # TODO + +cdef class EventLoop: + cdef async.SimpleEventLoop thisptr + + cpdef evalLater(self, func): + Py_INCREF(func) + return Promise()._init(async.evalLater(self.thisptr, func)) + + cdef wait(self, async.PyPromise * promise): + return self.thisptr.wait(movePromise(deref(promise))) + + cdef there(self, async.PyPromise * promise, object func, object error_func): + Py_INCREF(func) + Py_INCREF(error_func) + return Promise()._init(async.there(self.thisptr, deref(promise), func, error_func)) + + +cdef EventLoop c_event_loop = EventLoop() +event_loop = c_event_loop + +cdef class Promise: + cdef async.PyPromise * thisptr + cdef _init(self, async.PyPromise other): + self.thisptr = new async.PyPromise(movePromise(other)) + return self + + def __dealloc__(self): + del self.thisptr + + def wait(self): + return c_event_loop.wait(self.thisptr) + + def then(self, func, error_func=None): + return c_event_loop.there(self.thisptr, func, error_func) + diff --git a/capnp/asyncHelper.h b/capnp/asyncHelper.h new file mode 100644 index 0000000..62d44c9 --- /dev/null +++ b/capnp/asyncHelper.h @@ -0,0 +1,25 @@ +#include "kj/async.h" +#include "Python.h" +#include +extern "C" { + PyObject * wrap_kj_exception(kj::Exception &); +} + +PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { + PyObject * result = PyObject_CallFunctionObjArgs(func, arg, NULL); + Py_DECREF(func); + Py_DECREF(arg); + return result; +} + +::kj::Promise evalLater(kj::EventLoop & loop, PyObject * func) { + return loop.evalLater([func]() { return wrapPyFunc(func, NULL); } ); +} + +::kj::Promise there(kj::EventLoop & loop, kj::Promise & promise, PyObject * func, PyObject * error_func) { + if(error_func == Py_None) + return loop.there(kj::mv(promise), [func](PyObject * arg) { return wrapPyFunc(func, arg); } ); + else + return loop.there(kj::mv(promise), [func](PyObject * arg) { return wrapPyFunc(func, arg); } + , [error_func](kj::Exception arg) { return wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); +} \ No newline at end of file diff --git a/capnp/async_cpp.pxd b/capnp/async_cpp.pxd new file mode 100644 index 0000000..4e87530 --- /dev/null +++ b/capnp/async_cpp.pxd @@ -0,0 +1,31 @@ +# schema.capnp.cpp.pyx +# distutils: language = c++ +# distutils: extra_compile_args = --std=c++11 + +from cpython.ref cimport PyObject + +cdef extern from "kj/exception.h" namespace " ::kj": + cdef cppclass Exception: + pass + +cdef extern from "kj/async.h" namespace " ::kj": + cdef cppclass Promise[T]: + Promise(Promise) + T wait() + +ctypedef Promise[PyObject *] PyPromise + +cdef extern from "kj/async.h" namespace " ::kj": + cdef cppclass EventLoop: + EventLoop() + # Promise[void] yieldFrom'yield'() + object wait(PyPromise) + object there(PyPromise) + PyPromise evalLater(PyObject * func) + PyPromise there(PyPromise, PyObject * func) + cdef cppclass SimpleEventLoop(EventLoop): + pass + +cdef extern from "asyncHelper.h": + PyPromise evalLater(EventLoop &, PyObject * func) + PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) \ No newline at end of file From a4cd266f58d2fc42b99a57896480f51f20b46a87 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 18 Sep 2013 17:19:06 -0700 Subject: [PATCH 02/43] Update async a bit --- capnp/async.pyx | 2 +- capnp/asyncHelper.h | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/capnp/async.pyx b/capnp/async.pyx index 5c1b980..afe4605 100644 --- a/capnp/async.pyx +++ b/capnp/async.pyx @@ -14,7 +14,7 @@ from cython.operator cimport dereference as deref cdef extern from "" namespace "std": async.PyPromise movePromise"std::move"(async.PyPromise) -# This is a really weird function. By making it public, we'll be able to call it from asyncHelper.h +# By making it public, we'll be able to call it from asyncHelper.h cdef public object wrap_kj_exception(async.Exception & exception): return None # TODO diff --git a/capnp/asyncHelper.h b/capnp/asyncHelper.h index 62d44c9..f213375 100644 --- a/capnp/asyncHelper.h +++ b/capnp/asyncHelper.h @@ -1,6 +1,6 @@ #include "kj/async.h" #include "Python.h" -#include + extern "C" { PyObject * wrap_kj_exception(kj::Exception &); } @@ -8,7 +8,6 @@ extern "C" { PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { PyObject * result = PyObject_CallFunctionObjArgs(func, arg, NULL); Py_DECREF(func); - Py_DECREF(arg); return result; } From 8c559cc8b17ec474840f5e8fd79b6ad2e5d80293 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 18 Sep 2013 17:19:57 -0700 Subject: [PATCH 03/43] Add handling of DynamicObject --- capnp/capnp.pyx | 48 +++++++++++++++++++++++++++++++++++++++++---- capnp/capnp_cpp.pxd | 9 +++++++++ test/object.capnp | 21 ++++++++++++++++++++ test/test_object.py | 25 +++++++++++++++++++++++ 4 files changed, 99 insertions(+), 4 deletions(-) create mode 100644 test/object.capnp create mode 100644 test/test_object.py diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 8cfac42..9dc092e 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, WordArrayPtr +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, DynamicObject as C_DynamicObject, WordArrayPtr from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -352,7 +352,7 @@ cdef to_python_reader(C_DynamicValue.Reader self, object parent): elif type == capnp.TYPE_VOID: return None elif type == capnp.TYPE_OBJECT: - raise ValueError("Cannot convert type to Python. Object type is not supported in pycapnp yet") + return _DynamicObjectReader()._init(self.asObject(), parent) elif type == capnp.TYPE_UNKNOWN: raise ValueError("Cannot convert type to Python. Type is unknown by capnproto library") else: @@ -382,7 +382,7 @@ cdef to_python_builder(C_DynamicValue.Builder self, object parent): elif type == capnp.TYPE_VOID: return None elif type == capnp.TYPE_OBJECT: - raise ValueError("Cannot convert type to Python. Object type is not supported in pycapnp yet") + raise ValueError("Cannot convert type to Python. Type is 'Object', but is being used improperly. You can only get 'Object' types from a struct") elif type == capnp.TYPE_UNKNOWN: raise ValueError("Cannot convert type to Python. Type is unknown by capnproto library") else: @@ -618,7 +618,21 @@ cdef class _DynamicStructBuilder: return ret cdef _get(self, field): - return to_python_builder(self.thisptr.get(field), self._parent) + cdef C_DynamicValue.Builder value = self.thisptr.get(field) + + if value.getType() == capnp.TYPE_OBJECT: + return _DynamicObjectBuilder(field, self) + else: + return to_python_builder(value, self._parent) + + cpdef _get_object(self, field, schema): + cdef _StructSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + + return _DynamicStructBuilder()._init(self.thisptr.getObject(field, s.thisptr), self._parent) def __getattr__(self, field): return self._get(field) @@ -771,6 +785,32 @@ cdef class _DynamicOrphan: def __repr__(self): return repr(self.get()) +cdef class _DynamicObjectReader: + cdef C_DynamicObject.Reader thisptr + cdef public object _parent + cdef _init(self, C_DynamicObject.Reader other, object parent): + self.thisptr = other + self._parent = parent + return self + + cpdef as_struct(self, schema): + cdef _StructSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + + return _DynamicStructReader()._init(self.thisptr.as(s.thisptr), self._parent) + +cdef class _DynamicObjectBuilder: + cdef public object _field, _parent_struct + def __init__(self, field, parent_struct): + self._field = field + self._parent_struct = parent_struct + + cpdef as_struct(self, schema): + return self._parent_struct._get_object(self._field, schema) + cdef class _Schema: cdef C_Schema thisptr cdef _init(self, C_Schema other): diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index 8fe49b6..9f27652 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -138,6 +138,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": void adopt(char *, DynamicOrphan) except +ValueError DynamicOrphan disown(char *) DynamicStruct.Reader asReader() + DynamicStruct.Builder getObject(char *, StructSchema) cdef extern from "fixMaybe.h": EnumSchema.Enumerant fixMaybe(Maybe[EnumSchema.Enumerant]) except +ValueError @@ -149,6 +150,13 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": uint16_t getRaw() Maybe[EnumSchema.Enumerant] getEnumerant() + cdef cppclass DynamicObject: + cppclass Reader: + DynamicStruct.Reader as(StructSchema schema) + cppclass Builder: + DynamicObject.Reader asReader() + # DynamicList::Reader as(ListSchema schema) const; + cdef cppclass DynamicList: cppclass Reader: DynamicValueForward.Reader operator[](uint) except +ValueError @@ -193,6 +201,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": char * asText"as< ::capnp::Text>().cStr"() DynamicList.Reader asList"as< ::capnp::DynamicList>"() DynamicStruct.Reader asStruct"as< ::capnp::DynamicStruct>"() + DynamicObject.Reader asObject"as< ::capnp::DynamicObject>"() DynamicEnum asEnum"as< ::capnp::DynamicEnum>"() Data.Reader asData"as< ::capnp::Data>"() diff --git a/test/object.capnp b/test/object.capnp new file mode 100644 index 0000000..bd074c1 --- /dev/null +++ b/test/object.capnp @@ -0,0 +1,21 @@ +@0x8186ddb142b58556; + +struct Person { + id @0 :UInt32; + name @1 :Text; +} + +struct Place { + id @0 :UInt32; + name @1 :Text; +} + +struct Thing { + id @0 :UInt64; + value @1 :UInt64; +} + +struct TestObject { + object @0 :Object; +} + diff --git a/test/test_object.py b/test/test_object.py new file mode 100644 index 0000000..5d7af08 --- /dev/null +++ b/test/test_object.py @@ -0,0 +1,25 @@ +import pytest +import capnp +import os +import math + +this_dir = os.path.dirname(__file__) + +@pytest.fixture +def object(): + return capnp.load(os.path.join(this_dir, 'object.capnp')) + +def test_object_basic(object): + obj = object.TestObject.new_message() + person = obj.object.as_struct(object.Person) + person.name = 'test' + person.id = 1000 + + same_person = obj.object.as_struct(object.Person) + assert same_person.name == 'test' + assert same_person.id == 1000 + + obj_r = obj.as_reader() + same_person = obj_r.object.as_struct(object.Person) + assert same_person.name == 'test' + assert same_person.id == 1000 \ No newline at end of file From 346f5791ece7c08770f1ff1ba6e4243bec697f29 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 18 Sep 2013 21:07:10 -0700 Subject: [PATCH 04/43] Fix up formatting issues with test_object.py --- test/test_object.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/test_object.py b/test/test_object.py index 5d7af08..28beb03 100644 --- a/test/test_object.py +++ b/test/test_object.py @@ -1,7 +1,6 @@ import pytest import capnp import os -import math this_dir = os.path.dirname(__file__) @@ -22,4 +21,4 @@ def test_object_basic(object): obj_r = obj.as_reader() same_person = obj_r.object.as_struct(object.Person) assert same_person.name == 'test' - assert same_person.id == 1000 \ No newline at end of file + assert same_person.id == 1000 From 9678a0f5a7fa3bf6c12d5835b42f9d22c83000da Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Thu, 19 Sep 2013 13:59:25 -0700 Subject: [PATCH 05/43] Fix up async wrappers. Comment out gevent stuff for now --- capnp/async.pyx | 73 ++++++++++++++++++++++++++++++++++++++------- capnp/asyncHelper.h | 33 +++++++++++++++++++- capnp/async_cpp.pxd | 13 +++++--- 3 files changed, 103 insertions(+), 16 deletions(-) diff --git a/capnp/async.pyx b/capnp/async.pyx index afe4605..89eb15d 100644 --- a/capnp/async.pyx +++ b/capnp/async.pyx @@ -25,30 +25,81 @@ cdef class EventLoop: Py_INCREF(func) return Promise()._init(async.evalLater(self.thisptr, func)) - cdef wait(self, async.PyPromise * promise): - return self.thisptr.wait(movePromise(deref(promise))) + cpdef wait(self, Promise promise) except+: + if promise.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + ret = self.thisptr.wait(movePromise(deref(promise.thisptr))) + promise.is_consumed = True + + return ret + + cpdef there(self, Promise promise, object func, object error_func=None): + if promise.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') - cdef there(self, async.PyPromise * promise, object func, object error_func): Py_INCREF(func) Py_INCREF(error_func) - return Promise()._init(async.there(self.thisptr, deref(promise), func, error_func)) + return Promise()._init(async.there(self.thisptr, deref(promise.thisptr), func, error_func)) - -cdef EventLoop c_event_loop = EventLoop() -event_loop = c_event_loop + cpdef yield_end(self): + return Promise()._init(async.yield_end(self.thisptr)) cdef class Promise: cdef async.PyPromise * thisptr + cdef public bint is_consumed + + def __init__(self): + self.is_consumed = True + cdef _init(self, async.PyPromise other): + self.is_consumed = False self.thisptr = new async.PyPromise(movePromise(other)) return self def __dealloc__(self): del self.thisptr - def wait(self): - return c_event_loop.wait(self.thisptr) + cpdef wait(self) except+: + if self.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') - def then(self, func, error_func=None): - return c_event_loop.there(self.thisptr, func, error_func) + ret = self.thisptr.wait() + self.is_consumed = True + return ret + + cpdef then(self, func, error_func=None) except+: + if self.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + Py_INCREF(func) + Py_INCREF(error_func) + + return Promise()._init(async.then(deref(self.thisptr), func, error_func)) + +# from gevent.event import Event, AsyncResult +# import gevent + +# cdef object _event = Event() +# cdef object _start_loop = AsyncResult() + +# def _start_event_loop(): +# loop = EventLoop() +# _start_loop.set(loop) +# _event.wait() +# _event.clear() + +# _event_loop_greenlet = gevent.spawn(_start_event_loop) + +# event_loop = _start_loop.get() +# _event.set() + +# cdef public void _gevent_eventloop_prepare_to_sleep(): +# _event.clear() + +# cdef public void _gevent_eventloop_sleep(): +# _event.wait() + +# cdef public void _gevent_eventloop_wake(): +# _event.set() diff --git a/capnp/asyncHelper.h b/capnp/asyncHelper.h index f213375..ae115cf 100644 --- a/capnp/asyncHelper.h +++ b/capnp/asyncHelper.h @@ -3,6 +3,9 @@ extern "C" { PyObject * wrap_kj_exception(kj::Exception &); + // void _gevent_eventloop_prepare_to_sleep(); + // void _gevent_eventloop_sleep(); + // void _gevent_eventloop_wake(); } PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { @@ -21,4 +24,32 @@ PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { else return loop.there(kj::mv(promise), [func](PyObject * arg) { return wrapPyFunc(func, arg); } , [error_func](kj::Exception arg) { return wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); -} \ No newline at end of file +} +::kj::Promise then(kj::Promise & promise, PyObject * func, PyObject * error_func) { + if(error_func == Py_None) + return promise.then([func](PyObject * arg) { return wrapPyFunc(func, arg); } ); + else + return promise.then([func](PyObject * arg) { return wrapPyFunc(func, arg); } + , [error_func](kj::Exception arg) { return wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); +} + +::kj::Promise yield_end(kj::EventLoop & loop) { + return loop.there(loop.yield(), []() { Py_RETURN_NONE; } ); +} + +// class PyEventLoop final: public ::kj::EventLoop { +// public: +// PyEventLoop() {} +// ~PyEventLoop() noexcept(false) {} + +// protected: +// void prepareToSleep() noexcept override { +// _gevent_eventloop_prepare_to_sleep(); +// } +// void sleep() override { +// _gevent_eventloop_sleep(); +// } +// void wake() const override { +// _gevent_eventloop_wake(); +// } +// }; \ No newline at end of file diff --git a/capnp/async_cpp.pxd b/capnp/async_cpp.pxd index 4e87530..d26f489 100644 --- a/capnp/async_cpp.pxd +++ b/capnp/async_cpp.pxd @@ -18,9 +18,9 @@ ctypedef Promise[PyObject *] PyPromise cdef extern from "kj/async.h" namespace " ::kj": cdef cppclass EventLoop: EventLoop() - # Promise[void] yieldFrom'yield'() - object wait(PyPromise) - object there(PyPromise) + # Promise[void] yield_end'yield'() + object wait(PyPromise) except+ + object there(PyPromise) except+ PyPromise evalLater(PyObject * func) PyPromise there(PyPromise, PyObject * func) cdef cppclass SimpleEventLoop(EventLoop): @@ -28,4 +28,9 @@ cdef extern from "kj/async.h" namespace " ::kj": cdef extern from "asyncHelper.h": PyPromise evalLater(EventLoop &, PyObject * func) - PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) \ No newline at end of file + PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) + PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) + PyPromise yield_end(EventLoop & loop) + + # cdef cppclass PyEventLoop(EventLoop): + # pass \ No newline at end of file From 46049ecc360022cd9785c462b76f80c7c44731ee Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Thu, 19 Sep 2013 22:08:17 -0700 Subject: [PATCH 06/43] Delete yield_end function since yield was removed upstream --- capnp/async.pyx | 3 --- capnp/asyncHelper.h | 4 ---- capnp/async_cpp.pxd | 1 - 3 files changed, 8 deletions(-) diff --git a/capnp/async.pyx b/capnp/async.pyx index 89eb15d..79f6104 100644 --- a/capnp/async.pyx +++ b/capnp/async.pyx @@ -42,9 +42,6 @@ cdef class EventLoop: Py_INCREF(error_func) return Promise()._init(async.there(self.thisptr, deref(promise.thisptr), func, error_func)) - cpdef yield_end(self): - return Promise()._init(async.yield_end(self.thisptr)) - cdef class Promise: cdef async.PyPromise * thisptr cdef public bint is_consumed diff --git a/capnp/asyncHelper.h b/capnp/asyncHelper.h index ae115cf..7dca4f3 100644 --- a/capnp/asyncHelper.h +++ b/capnp/asyncHelper.h @@ -33,10 +33,6 @@ PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { , [error_func](kj::Exception arg) { return wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); } -::kj::Promise yield_end(kj::EventLoop & loop) { - return loop.there(loop.yield(), []() { Py_RETURN_NONE; } ); -} - // class PyEventLoop final: public ::kj::EventLoop { // public: // PyEventLoop() {} diff --git a/capnp/async_cpp.pxd b/capnp/async_cpp.pxd index d26f489..911378d 100644 --- a/capnp/async_cpp.pxd +++ b/capnp/async_cpp.pxd @@ -30,7 +30,6 @@ cdef extern from "asyncHelper.h": PyPromise evalLater(EventLoop &, PyObject * func) PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) - PyPromise yield_end(EventLoop & loop) # cdef cppclass PyEventLoop(EventLoop): # pass \ No newline at end of file From 630d4467bc2a4445d8b1b707912b3598864b4b72 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 24 Sep 2013 11:49:38 -0700 Subject: [PATCH 07/43] Fix changed API for DynamicObject/ObjectPointer --- capnp/capnp.pyx | 40 ++++++++++++++++++---------------------- capnp/capnp_cpp.pxd | 20 ++++++++++---------- 2 files changed, 28 insertions(+), 32 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 9dc092e..b18a873 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, DynamicObject as C_DynamicObject, WordArrayPtr +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -382,7 +382,7 @@ cdef to_python_builder(C_DynamicValue.Builder self, object parent): elif type == capnp.TYPE_VOID: return None elif type == capnp.TYPE_OBJECT: - raise ValueError("Cannot convert type to Python. Type is 'Object', but is being used improperly. You can only get 'Object' types from a struct") + return _DynamicObjectBuilder()._init(self.asObject(), parent) elif type == capnp.TYPE_UNKNOWN: raise ValueError("Cannot convert type to Python. Type is unknown by capnproto library") else: @@ -620,20 +620,8 @@ cdef class _DynamicStructBuilder: cdef _get(self, field): cdef C_DynamicValue.Builder value = self.thisptr.get(field) - if value.getType() == capnp.TYPE_OBJECT: - return _DynamicObjectBuilder(field, self) - else: - return to_python_builder(value, self._parent) - - cpdef _get_object(self, field, schema): - cdef _StructSchema s - if hasattr(schema, 'schema'): - s = schema.schema - else: - s = schema - - return _DynamicStructBuilder()._init(self.thisptr.getObject(field, s.thisptr), self._parent) - + return to_python_builder(value, self._parent) + def __getattr__(self, field): return self._get(field) @@ -800,16 +788,24 @@ cdef class _DynamicObjectReader: else: s = schema - return _DynamicStructReader()._init(self.thisptr.as(s.thisptr), self._parent) + return _DynamicStructReader()._init(self.thisptr.getAs(s.thisptr), self._parent) cdef class _DynamicObjectBuilder: - cdef public object _field, _parent_struct - def __init__(self, field, parent_struct): - self._field = field - self._parent_struct = parent_struct + cdef C_DynamicObject.Builder * thisptr + cdef public object _parent + cdef _init(self, C_DynamicObject.Builder other, object parent): + self.thisptr = new C_DynamicObject.Builder(other) + self._parent = parent + return self cpdef as_struct(self, schema): - return self._parent_struct._get_object(self._field, schema) + cdef _StructSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + + return _DynamicStructBuilder()._init(self.thisptr.getAs(s.thisptr), self._parent) cdef class _Schema: cdef C_Schema thisptr diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index 9f27652..006d748 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -138,7 +138,14 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": void adopt(char *, DynamicOrphan) except +ValueError DynamicOrphan disown(char *) DynamicStruct.Reader asReader() - DynamicStruct.Builder getObject(char *, StructSchema) + +cdef extern from "capnp/object.h" namespace " ::capnp": + cdef cppclass ObjectPointer: + cppclass Reader: + DynamicStruct.Reader getAs"getAs< ::capnp::DynamicStruct>"(StructSchema) + cppclass Builder: + Builder(Builder) + DynamicStruct.Builder getAs"getAs< ::capnp::DynamicStruct>"(StructSchema) cdef extern from "fixMaybe.h": EnumSchema.Enumerant fixMaybe(Maybe[EnumSchema.Enumerant]) except +ValueError @@ -150,13 +157,6 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": uint16_t getRaw() Maybe[EnumSchema.Enumerant] getEnumerant() - cdef cppclass DynamicObject: - cppclass Reader: - DynamicStruct.Reader as(StructSchema schema) - cppclass Builder: - DynamicObject.Reader asReader() - # DynamicList::Reader as(ListSchema schema) const; - cdef cppclass DynamicList: cppclass Reader: DynamicValueForward.Reader operator[](uint) except +ValueError @@ -201,12 +201,11 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": char * asText"as< ::capnp::Text>().cStr"() DynamicList.Reader asList"as< ::capnp::DynamicList>"() DynamicStruct.Reader asStruct"as< ::capnp::DynamicStruct>"() - DynamicObject.Reader asObject"as< ::capnp::DynamicObject>"() + ObjectPointer.Reader asObject"as< ::capnp::ObjectPointer>"() DynamicEnum asEnum"as< ::capnp::DynamicEnum>"() Data.Reader asData"as< ::capnp::Data>"() cppclass Builder: - Builder() Type getType() int64_t asInt"as"() uint64_t asUint"as"() @@ -215,6 +214,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": char * asText"as< ::capnp::Text>().cStr"() DynamicList.Builder asList"as< ::capnp::DynamicList>"() DynamicStruct.Builder asStruct"as< ::capnp::DynamicStruct>"() + ObjectPointer.Builder asObject"as< ::capnp::ObjectPointer>"() DynamicEnum asEnum"as< ::capnp::DynamicEnum>"() Data.Builder asData"as< ::capnp::Data>"() From 5639cb14b7a56156d35de16e6d282e40f5b5f4b2 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 24 Sep 2013 13:11:46 -0700 Subject: [PATCH 08/43] Add dealloc to DynamicObjectBuilder --- capnp/capnp.pyx | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index b18a873..cb8720d 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -776,6 +776,7 @@ cdef class _DynamicOrphan: cdef class _DynamicObjectReader: cdef C_DynamicObject.Reader thisptr cdef public object _parent + cdef _init(self, C_DynamicObject.Reader other, object parent): self.thisptr = other self._parent = parent @@ -793,11 +794,15 @@ cdef class _DynamicObjectReader: cdef class _DynamicObjectBuilder: cdef C_DynamicObject.Builder * thisptr cdef public object _parent + cdef _init(self, C_DynamicObject.Builder other, object parent): self.thisptr = new C_DynamicObject.Builder(other) self._parent = parent return self + def __dealloc__(self): + del self.thisptr + cpdef as_struct(self, schema): cdef _StructSchema s if hasattr(schema, 'schema'): From 0b67f3aeebed81c166c819c97af5990dac777f22 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 9 Oct 2013 22:36:55 -0700 Subject: [PATCH 09/43] Fix setting string fields to support all types of strings --- capnp/capnp.pyx | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index cb8720d..39634cc 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -410,7 +410,7 @@ cdef _setDynamicField(_DynamicSetterClasses thisptr, field, value, parent): elif value_type is bool: temp = C_DynamicValue.Reader(value) thisptr.set(field, temp) - elif value_type is str: + elif isinstance(value, basestring): temp = C_DynamicValue.Reader(value) thisptr.set(field, temp) elif value_type is list: @@ -429,13 +429,10 @@ cdef _setDynamicField(_DynamicSetterClasses thisptr, field, value, parent): cdef _to_dict(msg): msg_type = type(msg) - print msg_type if msg_type is _DynamicListBuilder or msg_type is _DynamicListReader or msg_type is _DynamicResizableListBuilder: - print 'in list' return [_to_dict(x) for x in msg] if msg_type is _DynamicStructBuilder or msg_type is _DynamicStructReader: - print 'in struct' ret = {} try: which = msg.which() @@ -445,7 +442,6 @@ cdef _to_dict(msg): pass for field in msg.schema.non_union_fields: - print field if msg._has(field): ret[field] = _to_dict(getattr(msg, field)) From 9391ed6759adf7b4d401087eed4047c731c815dc Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 15 Oct 2013 13:29:54 -0700 Subject: [PATCH 10/43] Wrap InterfaceSchema --- capnp/capnp.pyx | 51 +++++++++++++++++++++++++++------------------ capnp/capnp_cpp.pxd | 7 +++++-- 2 files changed, 36 insertions(+), 22 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 39634cc..4972eb0 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -61,7 +61,7 @@ _Type = _make_enum('DynamicValue.Type', LIST = capnp.TYPE_LIST, ENUM = capnp.TYPE_ENUM, STRUCT = capnp.TYPE_STRUCT, - INTERFACE = capnp.TYPE_INTERFACE, + # INTERFACE = capnp.TYPE_INTERFACE, OBJECT = capnp.TYPE_OBJECT) # Templated classes are weird in cython. I couldn't put it in a pxd header for some reason @@ -113,6 +113,9 @@ cdef class _NodeReader: property isConst: def __get__(self): return self.thisptr.isConst() + property isInterface: + def __get__(self): + return self.thisptr.isInterface() cdef class _NestedNodeReader: cdef C_Node.NestedNode.Reader thisptr @@ -820,6 +823,9 @@ cdef class _Schema: cpdef as_struct(self): return _StructSchema()._init(self.thisptr.asStruct()) + cpdef as_interface(self): + return _InterfaceSchema()._init(self.thisptr.asInterface()) + cpdef get_dependency(self, id): return _Schema()._init(self.thisptr.getDependency(id)) @@ -885,26 +891,22 @@ cdef class _StructSchema: def __repr__(self): return '' % self.node.displayName -cdef class _ParsedSchema: - cdef C_ParsedSchema thisptr - cdef _init(self, C_ParsedSchema other): +cdef class _InterfaceSchema: + cdef C_InterfaceSchema thisptr + + cdef _init(self, C_InterfaceSchema other): self.thisptr = other return self - cpdef as_const_value(self): - return to_python_reader(self.thisptr.asConst(), self) +cdef class _ParsedSchema(_Schema): + cdef C_ParsedSchema thisptr_child + cdef _init_child(self, C_ParsedSchema other): + self.thisptr_child = other + self._init(other) + return self - cpdef as_struct(self): - return _StructSchema()._init(self.thisptr.asStruct()) - - cpdef get_dependency(self, id): - return _Schema()._init(self.thisptr.getDependency(id)) - - cpdef get_proto(self): - return _NodeReader().init(self.thisptr.getProto()) - - cpdef getNested(self, name): - return _ParsedSchema()._init(self.thisptr.getNested(name)) + cpdef get_nested(self, name): + return _ParsedSchema()._init_child(self.thisptr_child.getNested(name)) class _StructABCMeta(type): """A metaclass for the Type.Reader and Type.Builder ABCs.""" @@ -932,7 +934,7 @@ cdef class SchemaParser: cdef ArrayPtr[StringPtr] importsPtr = ArrayPtr[StringPtr](importArray, len(imports)) ret = _ParsedSchema() - ret._init(self.thisptr.parseDiskFile(displayName, diskPath, importsPtr)) + ret._init_child(self.thisptr.parseDiskFile(displayName, diskPath, importsPtr)) free(importArray) @@ -980,7 +982,7 @@ cdef class SchemaParser: local_module = _ModuleType(node.name) module.__dict__[node.name] = local_module - schema = nodeSchema.getNested(node.name) + schema = nodeSchema.get_nested(node.name) proto = schema.get_proto() if proto.isStruct: local_module.schema = schema.as_struct() @@ -1015,6 +1017,11 @@ cdef class SchemaParser: _from_dict(msg, d) return msg return helper + def from_object(): + def helper(obj): + builder = _MallocMessageBuilder() + return builder.set_root(obj) + return helper class Reader(_DynamicStructReader): """An abstract base class. Readers are 'instances' of this class.""" __metaclass__ = _StructABCMeta @@ -1034,12 +1041,15 @@ cdef class SchemaParser: local_module.read = read(local_module) local_module.read_packed = read_packed(local_module) local_module.new_message = new_message(local_module) + local_module.from_object = from_object() local_module.from_dict = from_dict(local_module) local_module.from_bytes = make_from_bytes(local_module) local_module.Reader = Reader local_module.Builder = Builder elif proto.isConst: module.__dict__[node.name] = schema.as_const_value() + elif proto.isInterface: + local_module.schema = schema.as_interface() _load(schema, local_module) if not _os.path.isfile(file_name): @@ -1134,6 +1144,7 @@ cdef class _MessageBuilder: if type(value) is _DynamicStructBuilder: value = value.as_reader(); self.thisptr.setRootDynamicStruct((<_DynamicStructReader>value).thisptr) + return self.get_root(value.schema) cpdef new_orphan(self, schema): """A method for instantiating Cap'n Proto orphans diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index 006d748..b9a3a2c 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -56,7 +56,10 @@ cdef extern from "capnp/schema.h" namespace " ::capnp": EnumSchema asEnum() except + ConstSchema asConst() except + Schema getDependency(uint64_t id) except + - #InterfaceSchema asInterface() const; + InterfaceSchema asInterface() except + + + cdef cppclass InterfaceSchema(Schema): + pass cdef cppclass StructSchema(Schema): cppclass Field: @@ -116,7 +119,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": TYPE_LIST " ::capnp::DynamicValue::LIST" TYPE_ENUM " ::capnp::DynamicValue::ENUM" TYPE_STRUCT " ::capnp::DynamicValue::STRUCT" - TYPE_INTERFACE " ::capnp::DynamicValue::INTERFACE" + # TYPE_INTERFACE " ::capnp::DynamicValue::INTERFACE" TYPE_OBJECT " ::capnp::DynamicValue::OBJECT" cdef cppclass DynamicStruct: From a5d0abb49f0ce1a46636ddaaf5f4d29f766c6cb8 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 15 Oct 2013 22:36:14 -0700 Subject: [PATCH 11/43] First working version of capability interfaces --- capnp/async.h | 25 --- capnp/async.pyx | 102 ---------- capnp/asyncHelper_cpp.pxd | 14 ++ capnp/async_cpp.pxd | 11 +- capnp/capabilityHelper.h | 32 +++ capnp/capnp.pyx | 313 +++++++++++++++++++++++++++++- capnp/capnp_cpp.pxd | 72 ++++++- capnp/fixMaybe.h | 2 +- examples/example_capability.capnp | 45 +++++ examples/example_capability.py | 25 +++ test/test_capability.capnp | 45 +++++ test/test_capability.py | 30 +++ 12 files changed, 576 insertions(+), 140 deletions(-) delete mode 100644 capnp/async.h delete mode 100644 capnp/async.pyx create mode 100644 capnp/asyncHelper_cpp.pxd create mode 100644 capnp/capabilityHelper.h create mode 100644 examples/example_capability.capnp create mode 100644 examples/example_capability.py create mode 100644 test/test_capability.capnp create mode 100644 test/test_capability.py diff --git a/capnp/async.h b/capnp/async.h deleted file mode 100644 index 9b28e5a..0000000 --- a/capnp/async.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef __PYX_HAVE__capnp__async -#define __PYX_HAVE__capnp__async - - -#ifndef __PYX_HAVE_API__capnp__async - -#ifndef __PYX_EXTERN_C - #ifdef __cplusplus - #define __PYX_EXTERN_C extern "C" - #else - #define __PYX_EXTERN_C extern - #endif -#endif - -__PYX_EXTERN_C DL_IMPORT(PyObject) *wrap_kj_exception( ::kj::Exception &); - -#endif /* !__PYX_HAVE_API__capnp__async */ - -#if PY_MAJOR_VERSION < 3 -PyMODINIT_FUNC initasync(void); -#else -PyMODINIT_FUNC PyInit_async(void); -#endif - -#endif /* !__PYX_HAVE__capnp__async */ diff --git a/capnp/async.pyx b/capnp/async.pyx deleted file mode 100644 index 79f6104..0000000 --- a/capnp/async.pyx +++ /dev/null @@ -1,102 +0,0 @@ -# capnp.pyx -# distutils: language = c++ -# distutils: extra_compile_args = --std=c++11 -fpermissive -# distutils: libraries = kj -# cython: c_string_type = str -# cython: c_string_encoding = default -# cython: embedsignature = True - -cimport cython -cimport async_cpp as async -from cpython.ref cimport PyObject, Py_INCREF, Py_DECREF -from cython.operator cimport dereference as deref - -cdef extern from "" namespace "std": - async.PyPromise movePromise"std::move"(async.PyPromise) - -# By making it public, we'll be able to call it from asyncHelper.h -cdef public object wrap_kj_exception(async.Exception & exception): - return None # TODO - -cdef class EventLoop: - cdef async.SimpleEventLoop thisptr - - cpdef evalLater(self, func): - Py_INCREF(func) - return Promise()._init(async.evalLater(self.thisptr, func)) - - cpdef wait(self, Promise promise) except+: - if promise.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') - - ret = self.thisptr.wait(movePromise(deref(promise.thisptr))) - promise.is_consumed = True - - return ret - - cpdef there(self, Promise promise, object func, object error_func=None): - if promise.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') - - Py_INCREF(func) - Py_INCREF(error_func) - return Promise()._init(async.there(self.thisptr, deref(promise.thisptr), func, error_func)) - -cdef class Promise: - cdef async.PyPromise * thisptr - cdef public bint is_consumed - - def __init__(self): - self.is_consumed = True - - cdef _init(self, async.PyPromise other): - self.is_consumed = False - self.thisptr = new async.PyPromise(movePromise(other)) - return self - - def __dealloc__(self): - del self.thisptr - - cpdef wait(self) except+: - if self.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') - - ret = self.thisptr.wait() - self.is_consumed = True - - return ret - - cpdef then(self, func, error_func=None) except+: - if self.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') - - Py_INCREF(func) - Py_INCREF(error_func) - - return Promise()._init(async.then(deref(self.thisptr), func, error_func)) - -# from gevent.event import Event, AsyncResult -# import gevent - -# cdef object _event = Event() -# cdef object _start_loop = AsyncResult() - -# def _start_event_loop(): -# loop = EventLoop() -# _start_loop.set(loop) -# _event.wait() -# _event.clear() - -# _event_loop_greenlet = gevent.spawn(_start_event_loop) - -# event_loop = _start_loop.get() -# _event.set() - -# cdef public void _gevent_eventloop_prepare_to_sleep(): -# _event.clear() - -# cdef public void _gevent_eventloop_sleep(): -# _event.wait() - -# cdef public void _gevent_eventloop_wake(): -# _event.set() diff --git a/capnp/asyncHelper_cpp.pxd b/capnp/asyncHelper_cpp.pxd new file mode 100644 index 0000000..6ce1199 --- /dev/null +++ b/capnp/asyncHelper_cpp.pxd @@ -0,0 +1,14 @@ +# schema.capnp.cpp.pyx +# distutils: language = c++ +# distutils: extra_compile_args = --std=c++11 + +from cpython.ref cimport PyObject +from capnp_cpp cimport PyPromise, EventLoop + +cdef extern from "asyncHelper.h": + PyPromise evalLater(EventLoop &, PyObject * func) + PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) + PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) + + # cdef cppclass PyEventLoop(EventLoop): + # pass \ No newline at end of file diff --git a/capnp/async_cpp.pxd b/capnp/async_cpp.pxd index 911378d..3da574b 100644 --- a/capnp/async_cpp.pxd +++ b/capnp/async_cpp.pxd @@ -10,6 +10,7 @@ cdef extern from "kj/exception.h" namespace " ::kj": cdef extern from "kj/async.h" namespace " ::kj": cdef cppclass Promise[T]: + Promise() Promise(Promise) T wait() @@ -24,12 +25,4 @@ cdef extern from "kj/async.h" namespace " ::kj": PyPromise evalLater(PyObject * func) PyPromise there(PyPromise, PyObject * func) cdef cppclass SimpleEventLoop(EventLoop): - pass - -cdef extern from "asyncHelper.h": - PyPromise evalLater(EventLoop &, PyObject * func) - PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) - PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) - - # cdef cppclass PyEventLoop(EventLoop): - # pass \ No newline at end of file + pass \ No newline at end of file diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h new file mode 100644 index 0000000..60bf93d --- /dev/null +++ b/capnp/capabilityHelper.h @@ -0,0 +1,32 @@ +#include "capnp/dynamic.h" +#include +#include "Python.h" +#include + +extern "C" { + PyObject * wrap_dynamic_struct_reader(capnp::DynamicStruct::Reader &); + void call_server_method(PyObject * py_server, char * name, capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> & context); + } + +class PythonInterfaceDynamicImpl final: public capnp::DynamicCapability::Server { +public: + PyObject * py_server; + + PythonInterfaceDynamicImpl(capnp::InterfaceSchema & schema, PyObject * py_server) + : capnp::DynamicCapability::Server(schema), py_server(py_server) {} + + kj::Promise call(capnp::InterfaceSchema::Method method, + capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> context) { + auto methodName = method.getProto().getName(); + call_server_method(py_server, const_cast(methodName.cStr()), context); + return kj::READY_NOW; + } +}; + +capnp::DynamicCapability::Client new_client(capnp::InterfaceSchema & schema, PyObject * server, kj::EventLoop & loop) { + return capnp::DynamicCapability::Client(kj::heap(schema, server), loop); +} + +::kj::Promise convert_to_pypromise(capnp::RemotePromise & promise) { + return promise.then([](capnp::Response&& response) { return wrap_dynamic_struct_reader(response); } ); +} \ No newline at end of file diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 4972eb0..f66ade4 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,11 +9,13 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr, DynamicCapability as C_DynamicCapability, new_client, Request, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, CallContext from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref +cimport async_cpp +from cpython.ref cimport PyObject, Py_INCREF, Py_DECREF from libc.stdint cimport * ctypedef unsigned int uint ctypedef uint8_t UInt8 @@ -32,6 +34,21 @@ ctypedef double Float64 from libc.stdlib cimport malloc, free from libcpp cimport bool as cbool +# By making it public, we'll be able to call it from capabilityHelper.h +cdef public object wrap_dynamic_struct_reader(C_DynamicStruct.Reader & reader): + return _DynamicStructReader()._init(reader, None) + +cdef public void call_server_method(PyObject * _server, char * _method_name, CallContext & _context): + server = _server + method_name = _method_name + + context = _CallContext()._init(_context) + getattr(server, method_name)(context) + +# By making it public, we'll be able to call it from asyncHelper.h +cdef public object wrap_kj_exception(capnp.Exception & exception): + return None # TODO + ctypedef fused _DynamicStructReaderOrBuilder: _DynamicStructReader _DynamicStructBuilder @@ -39,6 +56,7 @@ ctypedef fused _DynamicStructReaderOrBuilder: ctypedef fused _DynamicSetterClasses: C_DynamicList.Builder C_DynamicStruct.Builder + Request cdef extern from "Python.h": cdef int PyObject_AsReadBuffer(object, void** b, Py_ssize_t* c) @@ -61,7 +79,7 @@ _Type = _make_enum('DynamicValue.Type', LIST = capnp.TYPE_LIST, ENUM = capnp.TYPE_ENUM, STRUCT = capnp.TYPE_STRUCT, - # INTERFACE = capnp.TYPE_INTERFACE, + CAPABILITY = capnp.TYPE_CAPABILITY, OBJECT = capnp.TYPE_OBJECT) # Templated classes are weird in cython. I couldn't put it in a pxd header for some reason @@ -76,16 +94,22 @@ cdef extern from "capnp/list.h" namespace " ::capnp": cdef extern from "" namespace "std": C_DynamicOrphan moveOrphan"std::move"(C_DynamicOrphan) + Request moveRequest"std::move"(Request) + PyPromise movePromise"std::move"(PyPromise) + RemotePromise moveRemotePromise"std::move"(RemotePromise) + CallContext moveCallContext"std::move"(CallContext) cdef extern from "" namespace " ::capnp": StringTree printStructReader" ::capnp::prettyPrint"(C_DynamicStruct.Reader) StringTree printStructBuilder" ::capnp::prettyPrint"(C_DynamicStruct.Builder) + StringTree printRequest" ::capnp::prettyPrint"(Request &) StringTree printListReader" ::capnp::prettyPrint"(C_DynamicList.Reader) StringTree printListBuilder" ::capnp::prettyPrint"(C_DynamicList.Builder) cdef extern from "" namespace " ::kj": String strStructReader" ::kj::str"(C_DynamicStruct.Reader) String strStructBuilder" ::kj::str"(C_DynamicStruct.Builder) + String strRequest" ::kj::str"(Request &) String strListReader" ::kj::str"(C_DynamicList.Reader) String strListBuilder" ::kj::str"(C_DynamicList.Builder) @@ -430,6 +454,39 @@ cdef _setDynamicField(_DynamicSetterClasses thisptr, field, value, parent): else: raise ValueError("Non primitive type") +cdef _setDynamicFieldPtr(_DynamicSetterClasses * thisptr, field, value, parent): + cdef C_DynamicValue.Reader temp + value_type = type(value) + + if value_type is int or value_type is long: + if value < 0: + temp = C_DynamicValue.Reader(value) + else: + temp = C_DynamicValue.Reader(value) + thisptr.set(field, temp) + elif value_type is float: + temp = C_DynamicValue.Reader(value) + thisptr.set(field, temp) + elif value_type is bool: + temp = C_DynamicValue.Reader(value) + thisptr.set(field, temp) + elif isinstance(value, basestring): + temp = C_DynamicValue.Reader(value) + thisptr.set(field, temp) + elif value_type is list: + builder = to_python_builder(thisptr.init(field, len(value)), parent) + for (i, v) in enumerate(value): + builder[i] = v + elif value is None: + temp = C_DynamicValue.Reader(VOID) + thisptr.set(field, temp) + elif value_type is _DynamicStructBuilder: + thisptr.set(field, _extract_dynamic_struct_builder(value)) + elif value_type is _DynamicStructReader: + thisptr.set(field, _extract_dynamic_struct_reader(value)) + else: + raise ValueError("Non primitive type") + cdef _to_dict(msg): msg_type = type(msg) if msg_type is _DynamicListBuilder or msg_type is _DynamicListReader or msg_type is _DynamicResizableListBuilder: @@ -811,6 +868,253 @@ cdef class _DynamicObjectBuilder: return _DynamicStructBuilder()._init(self.thisptr.getAs(s.thisptr), self._parent) +cdef class _CallContext: + cdef CallContext * thisptr + + cdef _init(self, CallContext other): + self.thisptr = new CallContext(moveCallContext(other)) + return self + + def __dealloc__(self): + del self.thisptr + + property params: + def __get__(self): + return _DynamicStructReader()._init(self.thisptr.getParams(), self) + + cpdef _get_results(self, uint firstSegmentWordSize=0): + return _DynamicStructBuilder()._init(self.thisptr.getResults(firstSegmentWordSize), self) + + property results: + def __get__(self): + return self._get_results() + +cdef class Promise: + cdef PyPromise * thisptr + + def __init__(self): + self.is_consumed = True + + cdef _init(self, PyPromise other): + self.is_consumed = False + self.thisptr = new PyPromise(movePromise(other)) + return self + + def __dealloc__(self): + del self.thisptr + + cpdef wait(self) except+: + if self.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + ret = self.thisptr.wait() + self.is_consumed = True + + return ret + + cpdef then(self, func, error_func=None) except+: + if self.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + Py_INCREF(func) + Py_INCREF(error_func) + + return Promise()._init(capnp.then(deref(self.thisptr), func, error_func)) + +cdef class _RemotePromise: + cdef RemotePromise * thisptr + cdef public bint is_consumed + cdef public object _parent + + def __init__(self): + self.is_consumed = True + + cdef _init(self, RemotePromise other, parent): + self.is_consumed = False + self.thisptr = new RemotePromise(moveRemotePromise(other)) + self._parent = parent + return self + + def __dealloc__(self): + del self.thisptr + + cpdef wait(self) except+: + if self.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + ret = _DynamicStructReader()._init(self.thisptr.wait(), self._parent) + self.is_consumed = True + + return ret + + cpdef as_pypromise(self) except +: + Promise()._init(convert_to_pypromise(deref(self.thisptr))) + + # cpdef then(self, func, error_func=None) except+: + # if self.is_consumed: + # raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + # Py_INCREF(func) + # Py_INCREF(error_func) + + # return _RemotePromise()._init(capnp.then(deref(self.thisptr), func, error_func)) + +cdef class EventLoop: + cdef SimpleEventLoop thisptr + cpdef evalLater(self, func): + Py_INCREF(func) + return Promise()._init(capnp.evalLater(self.thisptr, func)) + + cpdef wait_remote(self, _RemotePromise promise) except +: + if promise.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + ret = _DynamicStructReader()._init(self.thisptr.wait_remote(moveRemotePromise(deref(promise.thisptr))), promise._parent) + promise.is_consumed = True + + return ret + + # cpdef there(self, Promise promise, object func, object error_func=None): + # if promise.is_consumed: + # raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + # Py_INCREF(func) + # Py_INCREF(error_func) + # return Promise()._init(capnp.there(self.thisptr, deref(promise.thisptr), func, error_func)) + +cdef class _Request: + cdef Request * thisptr + cdef public object _parent + + cdef _init(self, Request other, parent): + self.thisptr = new Request(moveRequest(other)) + self._parent = parent + return self + + cpdef send(self): + return _RemotePromise()._init(self.thisptr.send(), self._parent) + cdef _get(self, field): + cdef C_DynamicValue.Builder value = self.thisptr.get(field) + + return to_python_builder(value, self._parent) + + def __getattr__(self, field): + return self._get(field) + + def __setattr__(self, field, value): + _setDynamicFieldPtr(self.thisptr, field, value, self._parent) + + def _has(self, field): + return self.thisptr.has(field) + + cpdef init(self, field, size=None): + """Method for initializing fields that are of type union/struct/list + + Typically, you don't have to worry about initializing structs/unions, so this method is mainly for lists. + + :type field: str + :param field: The field name to initialize + + :type size: int + :param size: The size of the list to initiialize. This should be None for struct/union initialization. + + :rtype: :class:`_DynamicStructBuilder` or :class:`_DynamicListBuilder` + + :Raises: :exc:`exceptions.ValueError` if the field isn't in this struct + """ + if size is None: + return to_python_builder(self.thisptr.init(field), self._parent) + else: + return to_python_builder(self.thisptr.init(field, size), self._parent) + + cpdef init_resizable_list(self, field): + """Method for initializing fields that are of type list (of structs) + + This version of init returns a :class:`_DynamicResizableListBuilder` that allows you to add members one at a time (ie. if you don't know the size for sure). This is only meant for lists of Cap'n Proto objects, since for primitive types you can just define a normal python list and fill it yourself. + + .. warning:: You need to call :meth:`_DynamicResizableListBuilder.finish` on the list object before serializing the Cap'n Proto message. Failure to do so will cause your objects not to be written out as well as leaking orphan structs into your message. + + :type field: str + :param field: The field name to initialize + + :rtype: :class:`_DynamicResizableListBuilder` + + :Raises: :exc:`exceptions.ValueError` if the field isn't in this struct + """ + return _DynamicResizableListBuilder(self, field, _StructSchema()._init((self.thisptr.get(field)).asList().getStructElementType())) + + cpdef which(self): + """Returns the enum corresponding to the union in this struct + + Enums are just strings in the python Cap'n Proto API, so this function will either return a string equal to the field name of the active field in the union, or throw a ValueError if this isn't a union, or a struct with an unnamed union:: + + person = addressbook.Person.new_message() + + person.which() + # ValueError: member was null + + a.employment.employer = 'foo' + print employment.which() + # 'employer' + + :rtype: str + :return: A string/enum corresponding to what field is set in the union + + :Raises: :exc:`exceptions.ValueError` if this struct doesn't contain a union + """ + cdef object which = getEnumString(deref(self.thisptr)) + if len(which) == 0: + raise ValueError("Attempted to call which on a non-union type") + + return which + + property schema: + """A property that returns the _StructSchema object matching this writer""" + def __get__(self): + return _StructSchema()._init(self.thisptr.getSchema()) + + def __dir__(self): + return list(self.schema.fieldnames) + + def __str__(self): + return printRequest(deref(self.thisptr)).flatten().cStr() + + def __repr__(self): + return '<%s builder %s>' % (self.schema.node.displayName, strRequest(deref(self.thisptr)).cStr()) + + def to_dict(self): + return _to_dict(self) + +cdef class _DynamicCapabilityClient: + cdef C_DynamicCapability.Client thisptr + cdef public object _event_loop, _server + + def __init__(self, schema, server, event_loop): + cdef _InterfaceSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + + cdef EventLoop loop = event_loop + self._event_loop = event_loop + self.thisptr = new_client(s.thisptr, server, loop.thisptr) + self._server = server + + cpdef _new_request_helper(self, name, firstSegmentWordSize, kwargs) except +ValueError: + cdef Request * request = new Request(self.thisptr.newRequest(name, firstSegmentWordSize)) + + for key, val in kwargs.items(): + _setDynamicFieldPtr(request, key, val, self) + + return _RemotePromise()._init(request.send(), self) + + cpdef request(self, name, firstSegmentWordSize=0) except +ValueError: + return _Request()._init(self.thisptr.newRequest(name, firstSegmentWordSize), self) + + def send(self, name, firstSegmentWordSize=0, **kwargs): + return self._new_request_helper(name, firstSegmentWordSize, kwargs) + cdef class _Schema: cdef C_Schema thisptr cdef _init(self, C_Schema other): @@ -1049,7 +1353,12 @@ cdef class SchemaParser: elif proto.isConst: module.__dict__[node.name] = schema.as_const_value() elif proto.isInterface: + def new_client(bound_local_module): + def helper(server, loop): + return _DynamicCapabilityClient(bound_local_module, server, loop) + return helper local_module.schema = schema.as_interface() + local_module.new_client = new_client(local_module) _load(schema, local_module) if not _os.path.isfile(file_name): diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index b9a3a2c..1c6a409 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -2,7 +2,9 @@ # distutils: language = c++ # distutils: extra_compile_args = --std=c++11 from schema_cpp cimport Node, Data, StructNode, EnumNode +from async_cpp cimport PyPromise, Promise +from cpython.ref cimport PyObject from libc.stdint cimport * ctypedef unsigned int uint from libcpp cimport bool as cbool @@ -13,6 +15,10 @@ cdef extern from "capnp/common.h" namespace " ::capnp": cdef cppclass word: pass +cdef extern from "kj/exception.h" namespace " ::kj": + cdef cppclass Exception: + pass + cdef extern from "kj/string.h" namespace " ::kj": cdef cppclass StringPtr: StringPtr(char *) @@ -119,7 +125,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": TYPE_LIST " ::capnp::DynamicValue::LIST" TYPE_ENUM " ::capnp::DynamicValue::ENUM" TYPE_STRUCT " ::capnp::DynamicValue::STRUCT" - # TYPE_INTERFACE " ::capnp::DynamicValue::INTERFACE" + TYPE_CAPABILITY " ::capnp::DynamicValue::CAPABILITY" TYPE_OBJECT " ::capnp::DynamicValue::OBJECT" cdef cppclass DynamicStruct: @@ -142,6 +148,31 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": DynamicOrphan disown(char *) DynamicStruct.Reader asReader() +cdef extern from "capnp/capability.h" namespace " ::capnp": + cdef cppclass Response" ::capnp::Response< ::capnp::DynamicStruct>"(DynamicStruct.Reader): + pass + cdef cppclass RemotePromise" ::capnp::RemotePromise< ::capnp::DynamicStruct>"(Promise[Response]): + RemotePromise(RemotePromise) + +cdef extern from "capnp/dynamic.h" namespace " ::capnp": + cdef cppclass Request" ::capnp::Request< ::capnp::DynamicStruct, ::capnp::DynamicStruct>": + Request() + Request(Request &) + DynamicValueForward.Builder get(char *) except +ValueError + bint has(char *) except +ValueError + void set(char *, DynamicValueForward.Reader) except +ValueError + DynamicValueForward.Builder init(char *, uint size) except +ValueError + DynamicValueForward.Builder init(char *) except +ValueError + StructSchema getSchema() + Maybe[StructSchema.Field] which() + RemotePromise send() + + cdef cppclass DynamicCapability: + cppclass Client: + Client upcast(InterfaceSchema requestedSchema) + InterfaceSchema getSchema() + Request newRequest(char * methodName, uint firstSegmentWordSize) + cdef extern from "capnp/object.h" namespace " ::capnp": cdef cppclass ObjectPointer: cppclass Reader: @@ -154,6 +185,14 @@ cdef extern from "fixMaybe.h": EnumSchema.Enumerant fixMaybe(Maybe[EnumSchema.Enumerant]) except +ValueError char * getEnumString(DynamicStruct.Reader val) char * getEnumString(DynamicStruct.Builder val) + char * getEnumString(Request val) + + +cdef extern from "capabilityHelper.h": + cppclass PythonInterfaceDynamicImpl: + pass + DynamicCapability.Client new_client(InterfaceSchema&, PyObject *, EventLoop&) + PyPromise convert_to_pypromise(RemotePromise&) cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef cppclass DynamicEnum: @@ -232,3 +271,34 @@ cdef extern from "capnp/orphan.h" namespace " ::capnp": cdef cppclass DynamicOrphan" ::capnp::Orphan< ::capnp::DynamicValue>": DynamicValue.Builder get() DynamicValue.Reader getReader() + +cdef extern from "capnp/capability.h" namespace " ::capnp": + cdef cppclass CallContext' ::capnp::CallContext< ::capnp::DynamicStruct, ::capnp::DynamicStruct>': + CallContext(CallContext&) + DynamicStruct.Reader getParams() except + + void releaseParams() + + DynamicStruct.Builder getResults(uint firstSegmentWordSize) + DynamicStruct.Builder initResults(uint firstSegmentWordSize) + void setResults(DynamicStruct.Reader value) + # void adoptResults(Orphan&& value); + # Orphanage getResultsOrphanage(uint firstSegmentWordSize = 0); + void allowAsyncCancellation(bint allow = true) + bint isCanceled() + +cdef extern from "kj/async.h" namespace " ::kj": + cdef cppclass EventLoop: + EventLoop() + # Promise[void] yield_end'yield'() + object wait(PyPromise) except+ + DynamicStruct.Reader wait_remote'wait'(RemotePromise) except+ + object there(PyPromise) except+ + PyPromise evalLater(PyObject * func) + PyPromise there(PyPromise, PyObject * func) + cdef cppclass SimpleEventLoop(EventLoop): + pass + +cdef extern from "asyncHelper.h": + PyPromise evalLater(EventLoop &, PyObject * func) + PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) + PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) diff --git a/capnp/fixMaybe.h b/capnp/fixMaybe.h index ac6fc2d..0f23106 100644 --- a/capnp/fixMaybe.h +++ b/capnp/fixMaybe.h @@ -13,7 +13,7 @@ T fixMaybe(::kj::Maybe val) { } template -const char * getEnumString(T val) { +const char * getEnumString(T & val) { auto maybe_val = val.which(); KJ_IF_MAYBE(new_val, maybe_val) { diff --git a/examples/example_capability.capnp b/examples/example_capability.capnp new file mode 100644 index 0000000..0bd862f --- /dev/null +++ b/examples/example_capability.capnp @@ -0,0 +1,45 @@ +# Copyright (c) 2013, Kenton Varda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +@0xd508eefec2dc42b8; + +interface TestInterface { + foo @0 (i :UInt32, j :Bool) -> (x: Text); + bar @1 () -> (); + # baz @2 (s: TestAllTypes); +} + +# interface TestExtends extends(TestInterface) { +# qux @0 (); +# corge @1 TestAllTypes -> (); +# grault @2 () -> TestAllTypes; +# } + +# interface TestPipeline { +# getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); +# testPointers @1 (cap :TestInterface, obj :Object, list :List(TestInterface)) -> (); + +# struct Box { +# cap @0 :TestInterface; +# } +# } diff --git a/examples/example_capability.py b/examples/example_capability.py new file mode 100644 index 0000000..2a4039a --- /dev/null +++ b/examples/example_capability.py @@ -0,0 +1,25 @@ +from __future__ import print_function + +import capnp +import example_capability_capnp + +class Server: + def foo(self, context): + context.results.x = str(context.params.i * 5 + 1) + +def example_client(): + loop = capnp.EventLoop() + + client = example_capability_capnp.TestInterface.new_client(Server(), loop) + + req = client.request('foo') + req = client.request('foo2') + req.i = 5 + + remote = req.send() + response = loop.wait_remote(remote) + + print(response.x) + +if __name__ == '__main__': + example_client() diff --git a/test/test_capability.capnp b/test/test_capability.capnp new file mode 100644 index 0000000..0bd862f --- /dev/null +++ b/test/test_capability.capnp @@ -0,0 +1,45 @@ +# Copyright (c) 2013, Kenton Varda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +@0xd508eefec2dc42b8; + +interface TestInterface { + foo @0 (i :UInt32, j :Bool) -> (x: Text); + bar @1 () -> (); + # baz @2 (s: TestAllTypes); +} + +# interface TestExtends extends(TestInterface) { +# qux @0 (); +# corge @1 TestAllTypes -> (); +# grault @2 () -> TestAllTypes; +# } + +# interface TestPipeline { +# getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); +# testPointers @1 (cap :TestInterface, obj :Object, list :List(TestInterface)) -> (); + +# struct Box { +# cap @0 :TestInterface; +# } +# } diff --git a/test/test_capability.py b/test/test_capability.py new file mode 100644 index 0000000..250fb83 --- /dev/null +++ b/test/test_capability.py @@ -0,0 +1,30 @@ +import pytest +import capnp +import os + +this_dir = os.path.dirname(__file__) + +@pytest.fixture +def capability(): + return capnp.load(os.path.join(this_dir, 'test_capability.capnp')) + +class Server: + def foo(self, context): + context.results.x = str(context.params.i * 5 + 1) + +def test_basic_client(capability): + loop = capnp.EventLoop() + + client = capability.TestInterface.new_client(Server(), loop) + + req = client.request('foo') + req.i = 5 + + remote = req.send() + remote = client.send('foo', i=10) + response = loop.wait_remote(remote) + + # assert response.x == '26' + + with pytest.raises(ValueError): + client.request('foo2') From 7f7b28f328c1112311f1b1538adec01f60ff356c Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Thu, 17 Oct 2013 19:15:40 -0700 Subject: [PATCH 12/43] Fix memleak and simplify dynamic client api --- capnp/capabilityHelper.h | 10 ++- capnp/capnp.pyx | 143 ++++++++------------------------- capnp/capnp_cpp.pxd | 4 +- examples/example_capability.py | 1 - test/test_capability.py | 50 +++++++++++- 5 files changed, 91 insertions(+), 117 deletions(-) diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index 60bf93d..414b975 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -12,8 +12,14 @@ class PythonInterfaceDynamicImpl final: public capnp::DynamicCapability::Server public: PyObject * py_server; - PythonInterfaceDynamicImpl(capnp::InterfaceSchema & schema, PyObject * py_server) - : capnp::DynamicCapability::Server(schema), py_server(py_server) {} + PythonInterfaceDynamicImpl(capnp::InterfaceSchema & schema, PyObject * _py_server) + : capnp::DynamicCapability::Server(schema), py_server(_py_server) { + Py_INCREF(_py_server); + } + + ~PythonInterfaceDynamicImpl() { + Py_DECREF(py_server); + } kj::Promise call(capnp::InterfaceSchema::Method method, capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> context) { diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index f66ade4..aee469a 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr, DynamicCapability as C_DynamicCapability, new_client, Request, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, CallContext +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr, DynamicCapability as C_DynamicCapability, new_client, Request, Response, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, CallContext from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -34,6 +34,12 @@ ctypedef double Float64 from libc.stdlib cimport malloc, free from libcpp cimport bool as cbool +from types import ModuleType as _ModuleType +import os as _os +import sys as _sys +import imp as _imp +from functools import partial as _partial + # By making it public, we'll be able to call it from capabilityHelper.h cdef public object wrap_dynamic_struct_reader(C_DynamicStruct.Reader & reader): return _DynamicStructReader()._init(reader, None) @@ -95,6 +101,7 @@ cdef extern from "capnp/list.h" namespace " ::capnp": cdef extern from "" namespace "std": C_DynamicOrphan moveOrphan"std::move"(C_DynamicOrphan) Request moveRequest"std::move"(Request) + Response moveResponse"std::move"(Response) PyPromise movePromise"std::move"(PyPromise) RemotePromise moveRemotePromise"std::move"(RemotePromise) CallContext moveCallContext"std::move"(CallContext) @@ -969,7 +976,7 @@ cdef class EventLoop: if promise.is_consumed: raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') - ret = _DynamicStructReader()._init(self.thisptr.wait_remote(moveRemotePromise(deref(promise.thisptr))), promise._parent) + ret = _Response()._init_child(self.thisptr.wait_remote(moveRemotePromise(deref(promise.thisptr))), promise._parent) promise.is_consumed = True return ret @@ -982,108 +989,24 @@ cdef class EventLoop: # Py_INCREF(error_func) # return Promise()._init(capnp.there(self.thisptr, deref(promise.thisptr), func, error_func)) -cdef class _Request: - cdef Request * thisptr - cdef public object _parent +cdef class _Request(_DynamicStructBuilder): + cdef Request * thisptr_child - cdef _init(self, Request other, parent): - self.thisptr = new Request(moveRequest(other)) - self._parent = parent + cdef _init_child(self, Request other, parent): + self.thisptr_child = new Request(moveRequest(other)) + self._init(deref(self.thisptr_child), parent) return self cpdef send(self): - return _RemotePromise()._init(self.thisptr.send(), self._parent) - cdef _get(self, field): - cdef C_DynamicValue.Builder value = self.thisptr.get(field) + return _RemotePromise()._init(self.thisptr_child.send(), self._parent) - return to_python_builder(value, self._parent) - - def __getattr__(self, field): - return self._get(field) +cdef class _Response(_DynamicStructReader): + cdef Response * thisptr_child - def __setattr__(self, field, value): - _setDynamicFieldPtr(self.thisptr, field, value, self._parent) - - def _has(self, field): - return self.thisptr.has(field) - - cpdef init(self, field, size=None): - """Method for initializing fields that are of type union/struct/list - - Typically, you don't have to worry about initializing structs/unions, so this method is mainly for lists. - - :type field: str - :param field: The field name to initialize - - :type size: int - :param size: The size of the list to initiialize. This should be None for struct/union initialization. - - :rtype: :class:`_DynamicStructBuilder` or :class:`_DynamicListBuilder` - - :Raises: :exc:`exceptions.ValueError` if the field isn't in this struct - """ - if size is None: - return to_python_builder(self.thisptr.init(field), self._parent) - else: - return to_python_builder(self.thisptr.init(field, size), self._parent) - - cpdef init_resizable_list(self, field): - """Method for initializing fields that are of type list (of structs) - - This version of init returns a :class:`_DynamicResizableListBuilder` that allows you to add members one at a time (ie. if you don't know the size for sure). This is only meant for lists of Cap'n Proto objects, since for primitive types you can just define a normal python list and fill it yourself. - - .. warning:: You need to call :meth:`_DynamicResizableListBuilder.finish` on the list object before serializing the Cap'n Proto message. Failure to do so will cause your objects not to be written out as well as leaking orphan structs into your message. - - :type field: str - :param field: The field name to initialize - - :rtype: :class:`_DynamicResizableListBuilder` - - :Raises: :exc:`exceptions.ValueError` if the field isn't in this struct - """ - return _DynamicResizableListBuilder(self, field, _StructSchema()._init((self.thisptr.get(field)).asList().getStructElementType())) - - cpdef which(self): - """Returns the enum corresponding to the union in this struct - - Enums are just strings in the python Cap'n Proto API, so this function will either return a string equal to the field name of the active field in the union, or throw a ValueError if this isn't a union, or a struct with an unnamed union:: - - person = addressbook.Person.new_message() - - person.which() - # ValueError: member was null - - a.employment.employer = 'foo' - print employment.which() - # 'employer' - - :rtype: str - :return: A string/enum corresponding to what field is set in the union - - :Raises: :exc:`exceptions.ValueError` if this struct doesn't contain a union - """ - cdef object which = getEnumString(deref(self.thisptr)) - if len(which) == 0: - raise ValueError("Attempted to call which on a non-union type") - - return which - - property schema: - """A property that returns the _StructSchema object matching this writer""" - def __get__(self): - return _StructSchema()._init(self.thisptr.getSchema()) - - def __dir__(self): - return list(self.schema.fieldnames) - - def __str__(self): - return printRequest(deref(self.thisptr)).flatten().cStr() - - def __repr__(self): - return '<%s builder %s>' % (self.schema.node.displayName, strRequest(deref(self.thisptr)).cStr()) - - def to_dict(self): - return _to_dict(self) + cdef _init_child(self, Response other, parent): + self.thisptr_child = new Response(moveResponse(other)) + self._init(deref(self.thisptr_child), parent) + return self cdef class _DynamicCapabilityClient: cdef C_DynamicCapability.Client thisptr @@ -1101,7 +1024,7 @@ cdef class _DynamicCapabilityClient: self.thisptr = new_client(s.thisptr, server, loop.thisptr) self._server = server - cpdef _new_request_helper(self, name, firstSegmentWordSize, kwargs) except +ValueError: + cpdef _send_helper(self, name, firstSegmentWordSize, kwargs) except +ValueError: cdef Request * request = new Request(self.thisptr.newRequest(name, firstSegmentWordSize)) for key, val in kwargs.items(): @@ -1109,11 +1032,20 @@ cdef class _DynamicCapabilityClient: return _RemotePromise()._init(request.send(), self) - cpdef request(self, name, firstSegmentWordSize=0) except +ValueError: - return _Request()._init(self.thisptr.newRequest(name, firstSegmentWordSize), self) + cpdef _request_helper(self, name, firstSegmentWordSize=0) except +ValueError: + return _Request()._init_child(self.thisptr.newRequest(name, firstSegmentWordSize), self) - def send(self, name, firstSegmentWordSize=0, **kwargs): - return self._new_request_helper(name, firstSegmentWordSize, kwargs) + def _request(self, name, firstSegmentWordSize=0): + return self._request_helper(name, firstSegmentWordSize) + + def _send(self, name, *args, firstSegmentWordSize=0, **kwargs): + return self._send_helper(name, firstSegmentWordSize, kwargs) + + def __getattr__(self, name): + if name.endswith('_request'): + short_name = name[:-8] + return _partial(self._request, short_name) + return _partial(self._send, name) cdef class _Schema: cdef C_Schema thisptr @@ -1630,11 +1562,6 @@ def _write_packed_message_to_fd(int fd, _MessageBuilder message): """ schema_cpp.writePackedMessageToFd(fd, deref(message.thisptr)) -from types import ModuleType as _ModuleType -import os as _os -import sys as _sys -import imp as _imp - _global_schema_parser = None def load(file_name, display_name=None, imports=[]): diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index 1c6a409..e24f7c9 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -150,7 +150,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef extern from "capnp/capability.h" namespace " ::capnp": cdef cppclass Response" ::capnp::Response< ::capnp::DynamicStruct>"(DynamicStruct.Reader): - pass + Response(Response) cdef cppclass RemotePromise" ::capnp::RemotePromise< ::capnp::DynamicStruct>"(Promise[Response]): RemotePromise(RemotePromise) @@ -291,7 +291,7 @@ cdef extern from "kj/async.h" namespace " ::kj": EventLoop() # Promise[void] yield_end'yield'() object wait(PyPromise) except+ - DynamicStruct.Reader wait_remote'wait'(RemotePromise) except+ + Response wait_remote'wait'(RemotePromise) object there(PyPromise) except+ PyPromise evalLater(PyObject * func) PyPromise there(PyPromise, PyObject * func) diff --git a/examples/example_capability.py b/examples/example_capability.py index 2a4039a..42c40c3 100644 --- a/examples/example_capability.py +++ b/examples/example_capability.py @@ -13,7 +13,6 @@ def example_client(): client = example_capability_capnp.TestInterface.new_client(Server(), loop) req = client.request('foo') - req = client.request('foo2') req.i = 5 remote = req.send() diff --git a/test/test_capability.py b/test/test_capability.py index 250fb83..e8dddac 100644 --- a/test/test_capability.py +++ b/test/test_capability.py @@ -17,14 +17,56 @@ def test_basic_client(capability): client = capability.TestInterface.new_client(Server(), loop) - req = client.request('foo') + req = client._request('foo') req.i = 5 remote = req.send() - remote = client.send('foo', i=10) response = loop.wait_remote(remote) - # assert response.x == '26' + assert response.x == '26' + + req = client.foo_request() + req.i = 5 + + remote = req.send() + response = loop.wait_remote(remote) + + assert response.x == '26' with pytest.raises(ValueError): - client.request('foo2') + client.foo2_request() + + req = client.foo_request() + + with pytest.raises(ValueError): + req.i = 'foo' + + req = client.foo_request() + + with pytest.raises(ValueError): + req.baz = 1 + +def test_simple_client(capability): + loop = capnp.EventLoop() + + client = capability.TestInterface.new_client(Server(), loop) + + remote = client._send('foo', i=5) + response = loop.wait_remote(remote) + + assert response.x == '26' + + + remote = client.foo(i=5) + response = loop.wait_remote(remote) + + assert response.x == '26' + + with pytest.raises(ValueError): + remote = client.foo(i='foo') + + with pytest.raises(ValueError): + remote = client.foo2(i=5) + + with pytest.raises(ValueError): + remote = client.foo(baz=5) From 96bfc495d88cb43b447e66780d64c3eab263e268 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Thu, 17 Oct 2013 22:42:14 -0700 Subject: [PATCH 13/43] Pipelining almost completely wrapped Waiting on some upstream changes in C++ libcapnp before I can finish --- capnp/asyncHelper.h | 51 ----------------- capnp/asyncHelper_cpp.pxd | 14 ----- capnp/async_cpp.pxd | 1 + capnp/capabilityHelper.h | 47 +++++++++++++++- capnp/capnp.pyx | 112 ++++++++++++++++++++++++++++++++----- capnp/capnp_cpp.pxd | 25 ++++++--- test/test_capability.capnp | 14 ++--- test/test_capability.py | 30 +++++++++- 8 files changed, 194 insertions(+), 100 deletions(-) delete mode 100644 capnp/asyncHelper.h delete mode 100644 capnp/asyncHelper_cpp.pxd diff --git a/capnp/asyncHelper.h b/capnp/asyncHelper.h deleted file mode 100644 index 7dca4f3..0000000 --- a/capnp/asyncHelper.h +++ /dev/null @@ -1,51 +0,0 @@ -#include "kj/async.h" -#include "Python.h" - -extern "C" { - PyObject * wrap_kj_exception(kj::Exception &); - // void _gevent_eventloop_prepare_to_sleep(); - // void _gevent_eventloop_sleep(); - // void _gevent_eventloop_wake(); -} - -PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { - PyObject * result = PyObject_CallFunctionObjArgs(func, arg, NULL); - Py_DECREF(func); - return result; -} - -::kj::Promise evalLater(kj::EventLoop & loop, PyObject * func) { - return loop.evalLater([func]() { return wrapPyFunc(func, NULL); } ); -} - -::kj::Promise there(kj::EventLoop & loop, kj::Promise & promise, PyObject * func, PyObject * error_func) { - if(error_func == Py_None) - return loop.there(kj::mv(promise), [func](PyObject * arg) { return wrapPyFunc(func, arg); } ); - else - return loop.there(kj::mv(promise), [func](PyObject * arg) { return wrapPyFunc(func, arg); } - , [error_func](kj::Exception arg) { return wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); -} -::kj::Promise then(kj::Promise & promise, PyObject * func, PyObject * error_func) { - if(error_func == Py_None) - return promise.then([func](PyObject * arg) { return wrapPyFunc(func, arg); } ); - else - return promise.then([func](PyObject * arg) { return wrapPyFunc(func, arg); } - , [error_func](kj::Exception arg) { return wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); -} - -// class PyEventLoop final: public ::kj::EventLoop { -// public: -// PyEventLoop() {} -// ~PyEventLoop() noexcept(false) {} - -// protected: -// void prepareToSleep() noexcept override { -// _gevent_eventloop_prepare_to_sleep(); -// } -// void sleep() override { -// _gevent_eventloop_sleep(); -// } -// void wake() const override { -// _gevent_eventloop_wake(); -// } -// }; \ No newline at end of file diff --git a/capnp/asyncHelper_cpp.pxd b/capnp/asyncHelper_cpp.pxd deleted file mode 100644 index 6ce1199..0000000 --- a/capnp/asyncHelper_cpp.pxd +++ /dev/null @@ -1,14 +0,0 @@ -# schema.capnp.cpp.pyx -# distutils: language = c++ -# distutils: extra_compile_args = --std=c++11 - -from cpython.ref cimport PyObject -from capnp_cpp cimport PyPromise, EventLoop - -cdef extern from "asyncHelper.h": - PyPromise evalLater(EventLoop &, PyObject * func) - PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) - PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) - - # cdef cppclass PyEventLoop(EventLoop): - # pass \ No newline at end of file diff --git a/capnp/async_cpp.pxd b/capnp/async_cpp.pxd index 3da574b..3817010 100644 --- a/capnp/async_cpp.pxd +++ b/capnp/async_cpp.pxd @@ -15,6 +15,7 @@ cdef extern from "kj/async.h" namespace " ::kj": T wait() ctypedef Promise[PyObject *] PyPromise +ctypedef Promise[void] VoidPromise cdef extern from "kj/async.h" namespace " ::kj": cdef cppclass EventLoop: diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index 414b975..eee76de 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -4,10 +4,46 @@ #include extern "C" { + void wrap_remote_call(PyObject * func, capnp::Response &); PyObject * wrap_dynamic_struct_reader(capnp::DynamicStruct::Reader &); - void call_server_method(PyObject * py_server, char * name, capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> & context); + ::kj::Promise * call_server_method(PyObject * py_server, char * name, capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> & context); + PyObject * wrap_kj_exception(kj::Exception &); } +PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { + PyObject * result = PyObject_CallFunctionObjArgs(func, arg, NULL); + Py_DECREF(func); + return result; +} + +::kj::Promise evalLater(kj::EventLoop & loop, PyObject * func) { + return loop.evalLater([func]() { return wrapPyFunc(func, NULL); } ); +} + +::kj::Promise there(kj::EventLoop & loop, kj::Promise & promise, PyObject * func, PyObject * error_func) { + if(error_func == Py_None) + return loop.there(kj::mv(promise), [func](PyObject * arg) { return wrapPyFunc(func, arg); } ); + else + return loop.there(kj::mv(promise), [func](PyObject * arg) { return wrapPyFunc(func, arg); } + , [error_func](kj::Exception arg) { return wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); +} + +::kj::Promise then(kj::Promise & promise, PyObject * func, PyObject * error_func) { + if(error_func == Py_None) + return promise.then([func](PyObject * arg) { return wrapPyFunc(func, arg); } ); + else + return promise.then([func](PyObject * arg) { return wrapPyFunc(func, arg); } + , [error_func](kj::Exception arg) { return wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); +} + +::kj::Promise then(::capnp::RemotePromise< ::capnp::DynamicStruct> & promise, PyObject * func, PyObject * error_func) { + if(error_func == Py_None) + return promise.then([func](capnp::Response&& arg) { wrap_remote_call(func, arg); } ); + else + return promise.then([func](capnp::Response&& arg) { wrap_remote_call(func, arg); } + , [error_func](kj::Exception arg) { wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); +} + class PythonInterfaceDynamicImpl final: public capnp::DynamicCapability::Server { public: PyObject * py_server; @@ -24,8 +60,13 @@ public: kj::Promise call(capnp::InterfaceSchema::Method method, capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> context) { auto methodName = method.getProto().getName(); - call_server_method(py_server, const_cast(methodName.cStr()), context); - return kj::READY_NOW; + kj::Promise * promise = call_server_method(py_server, const_cast(methodName.cStr()), context); + if(promise == nullptr) + return kj::READY_NOW; + + kj::Promise ret(kj::mv(*promise)); + delete promise; + return ret; } }; diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index aee469a..fd4b647 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr, DynamicCapability as C_DynamicCapability, new_client, Request, Response, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, CallContext +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr, DynamicCapability as C_DynamicCapability, new_client, Request, Response, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, VoidPromise, CallContext from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -44,14 +44,28 @@ from functools import partial as _partial cdef public object wrap_dynamic_struct_reader(C_DynamicStruct.Reader & reader): return _DynamicStructReader()._init(reader, None) -cdef public void call_server_method(PyObject * _server, char * _method_name, CallContext & _context): +cdef public void wrap_remote_call(PyObject * func, Response & r): + response = _Response()._init_childptr(new Response(moveResponse(r)), None) + + func_obj = func + # TODO: decref func? + func_obj(response) + +cdef public VoidPromise * call_server_method(PyObject * _server, char * _method_name, CallContext & _context): server = _server method_name = _method_name context = _CallContext()._init(_context) - getattr(server, method_name)(context) + ret = getattr(server, method_name)(context) -# By making it public, we'll be able to call it from asyncHelper.h + if ret is not None: + if type(ret) is _VoidPromise: + return new VoidPromise(moveVoidPromise(deref((<_VoidPromise>ret).thisptr))) + else: + raise ValueError('Server function returned a value that was not a VoidPromise: ' + str(ret)) + + return NULL + cdef public object wrap_kj_exception(capnp.Exception & exception): return None # TODO @@ -103,6 +117,7 @@ cdef extern from "" namespace "std": Request moveRequest"std::move"(Request) Response moveResponse"std::move"(Response) PyPromise movePromise"std::move"(PyPromise) + VoidPromise moveVoidPromise"std::move"(VoidPromise) RemotePromise moveRemotePromise"std::move"(RemotePromise) CallContext moveCallContext"std::move"(CallContext) @@ -301,8 +316,6 @@ cdef class _DynamicListBuilder: return self._get(index) def __setitem__(self, index, value): - # TODO: share code with _DynamicStructBuilder.__setattr__ - size = self.thisptr.size() if index >= size: raise IndexError('Out of bounds') @@ -387,6 +400,8 @@ cdef to_python_reader(C_DynamicValue.Reader self, object parent): return None elif type == capnp.TYPE_OBJECT: return _DynamicObjectReader()._init(self.asObject(), parent) + elif type == capnp.TYPE_CAPABILITY: + return _DynamicCapabilityClient()._init(self.asCapability(), parent) elif type == capnp.TYPE_UNKNOWN: raise ValueError("Cannot convert type to Python. Type is unknown by capnproto library") else: @@ -417,6 +432,8 @@ cdef to_python_builder(C_DynamicValue.Builder self, object parent): return None elif type == capnp.TYPE_OBJECT: return _DynamicObjectBuilder()._init(self.asObject(), parent) + elif type == capnp.TYPE_CAPABILITY: + return _DynamicCapabilityClient()._init(self.asCapability(), parent) elif type == capnp.TYPE_UNKNOWN: raise ValueError("Cannot convert type to Python. Type is unknown by capnproto library") else: @@ -428,6 +445,9 @@ cdef C_DynamicValue.Reader _extract_dynamic_struct_builder(_DynamicStructBuilder cdef C_DynamicValue.Reader _extract_dynamic_struct_reader(_DynamicStructReader value): return C_DynamicValue.Reader(value.thisptr) +cdef C_DynamicValue.Reader _extract_dynamic_client(_DynamicCapabilityClient value): + return C_DynamicValue.Reader(value.thisptr) + cdef _setDynamicField(_DynamicSetterClasses thisptr, field, value, parent): cdef C_DynamicValue.Reader temp value_type = type(value) @@ -458,6 +478,8 @@ cdef _setDynamicField(_DynamicSetterClasses thisptr, field, value, parent): thisptr.set(field, _extract_dynamic_struct_builder(value)) elif value_type is _DynamicStructReader: thisptr.set(field, _extract_dynamic_struct_reader(value)) + elif value_type is _DynamicCapabilityClient: + thisptr.set(field, _extract_dynamic_client(value)) else: raise ValueError("Non primitive type") @@ -491,6 +513,8 @@ cdef _setDynamicFieldPtr(_DynamicSetterClasses * thisptr, field, value, parent): thisptr.set(field, _extract_dynamic_struct_builder(value)) elif value_type is _DynamicStructReader: thisptr.set(field, _extract_dynamic_struct_reader(value)) + elif value_type is _DynamicCapabilityClient: + thisptr.set(field, _extract_dynamic_client(value)) else: raise ValueError("Non primitive type") @@ -898,6 +922,7 @@ cdef class _CallContext: cdef class Promise: cdef PyPromise * thisptr + cdef public bint is_consumed def __init__(self): self.is_consumed = True @@ -928,6 +953,38 @@ cdef class Promise: return Promise()._init(capnp.then(deref(self.thisptr), func, error_func)) +cdef class _VoidPromise: + cdef VoidPromise * thisptr + cdef public bint is_consumed + + def __init__(self): + self.is_consumed = True + + cdef _init(self, VoidPromise other): + self.is_consumed = False + self.thisptr = new VoidPromise(moveVoidPromise(other)) + return self + + def __dealloc__(self): + del self.thisptr + + cpdef wait(self) except+: + if self.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + self.thisptr.wait() + self.is_consumed = True + + + # cpdef then(self, func, error_func=None) except+: + # if self.is_consumed: + # raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + # Py_INCREF(func) + # Py_INCREF(error_func) + + # return Promise()._init(capnp.then(deref(self.thisptr), func, error_func)) + cdef class _RemotePromise: cdef RemotePromise * thisptr cdef public bint is_consumed @@ -957,14 +1014,28 @@ cdef class _RemotePromise: cpdef as_pypromise(self) except +: Promise()._init(convert_to_pypromise(deref(self.thisptr))) - # cpdef then(self, func, error_func=None) except+: - # if self.is_consumed: - # raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + cpdef then(self, func, error_func=None) except+: + if self.is_consumed: + raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') - # Py_INCREF(func) - # Py_INCREF(error_func) + Py_INCREF(func) + Py_INCREF(error_func) - # return _RemotePromise()._init(capnp.then(deref(self.thisptr), func, error_func)) + return _VoidPromise()._init(capnp.then(deref(self.thisptr), func, error_func)) + + cpdef _get(self, field) except +ValueError: + return _DynamicCapabilityClient()._init((self.thisptr.get(field)).asCapability(), self._parent) + + def __getattr__(self, field): + return self._get(field) + + property schema: + """A property that returns the _StructSchema object matching this reader""" + def __get__(self): + return _StructSchema()._init(self.thisptr.getSchema()) + + def __dir__(self): + return list(self.schema.fieldnames) cdef class EventLoop: cdef SimpleEventLoop thisptr @@ -1008,11 +1079,21 @@ cdef class _Response(_DynamicStructReader): self._init(deref(self.thisptr_child), parent) return self + cdef _init_childptr(self, Response * other, parent): + self.thisptr_child = other + self._init(deref(self.thisptr_child), parent) + return self + cdef class _DynamicCapabilityClient: cdef C_DynamicCapability.Client thisptr - cdef public object _event_loop, _server + cdef public object _event_loop, _server, _parent - def __init__(self, schema, server, event_loop): + cdef _init(self, C_DynamicCapability.Client other, object parent): + self.thisptr = other + self._parent = parent + return self + + cdef _init_vals(self, schema, server, event_loop): cdef _InterfaceSchema s if hasattr(schema, 'schema'): s = schema.schema @@ -1023,6 +1104,7 @@ cdef class _DynamicCapabilityClient: self._event_loop = event_loop self.thisptr = new_client(s.thisptr, server, loop.thisptr) self._server = server + return self cpdef _send_helper(self, name, firstSegmentWordSize, kwargs) except +ValueError: cdef Request * request = new Request(self.thisptr.newRequest(name, firstSegmentWordSize)) @@ -1287,7 +1369,7 @@ cdef class SchemaParser: elif proto.isInterface: def new_client(bound_local_module): def helper(server, loop): - return _DynamicCapabilityClient(bound_local_module, server, loop) + return _DynamicCapabilityClient()._init_vals(bound_local_module, server, loop) return helper local_module.schema = schema.as_interface() local_module.new_client = new_client(local_module) diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index e24f7c9..077d2d5 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -2,7 +2,7 @@ # distutils: language = c++ # distutils: extra_compile_args = --std=c++11 from schema_cpp cimport Node, Data, StructNode, EnumNode -from async_cpp cimport PyPromise, Promise +from async_cpp cimport PyPromise, VoidPromise, Promise from cpython.ref cimport PyObject from libc.stdint cimport * @@ -112,6 +112,8 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": pass cppclass Builder: pass + cppclass Pipeline: + pass enum Type: TYPE_UNKNOWN " ::capnp::DynamicValue::UNKNOWN" @@ -147,11 +149,14 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": void adopt(char *, DynamicOrphan) except +ValueError DynamicOrphan disown(char *) DynamicStruct.Reader asReader() + cppclass Pipeline: + DynamicValueForward.Pipeline get(char *) + StructSchema getSchema() cdef extern from "capnp/capability.h" namespace " ::capnp": cdef cppclass Response" ::capnp::Response< ::capnp::DynamicStruct>"(DynamicStruct.Reader): Response(Response) - cdef cppclass RemotePromise" ::capnp::RemotePromise< ::capnp::DynamicStruct>"(Promise[Response]): + cdef cppclass RemotePromise" ::capnp::RemotePromise< ::capnp::DynamicStruct>"(Promise[Response], DynamicStruct.Pipeline): RemotePromise(RemotePromise) cdef extern from "capnp/dynamic.h" namespace " ::capnp": @@ -189,6 +194,10 @@ cdef extern from "fixMaybe.h": cdef extern from "capabilityHelper.h": + PyPromise evalLater(EventLoop &, PyObject * func) + PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) + PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) + VoidPromise then(RemotePromise & promise, PyObject * func, PyObject * error_func) cppclass PythonInterfaceDynamicImpl: pass DynamicCapability.Client new_client(InterfaceSchema&, PyObject *, EventLoop&) @@ -235,6 +244,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": Reader(DynamicList.Reader& value) Reader(DynamicEnum value) Reader(DynamicStruct.Reader& value) + Reader(DynamicCapability.Client& value) Type getType() int64_t asInt"as"() uint64_t asUint"as"() @@ -244,6 +254,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": DynamicList.Reader asList"as< ::capnp::DynamicList>"() DynamicStruct.Reader asStruct"as< ::capnp::DynamicStruct>"() ObjectPointer.Reader asObject"as< ::capnp::ObjectPointer>"() + DynamicCapability.Client asCapability"as< ::capnp::DynamicCapability>"() DynamicEnum asEnum"as< ::capnp::DynamicEnum>"() Data.Reader asData"as< ::capnp::Data>"() @@ -257,9 +268,14 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": DynamicList.Builder asList"as< ::capnp::DynamicList>"() DynamicStruct.Builder asStruct"as< ::capnp::DynamicStruct>"() ObjectPointer.Builder asObject"as< ::capnp::ObjectPointer>"() + DynamicCapability.Client asCapability"as< ::capnp::DynamicCapability>"() DynamicEnum asEnum"as< ::capnp::DynamicEnum>"() Data.Builder asData"as< ::capnp::Data>"() + cppclass Pipeline: + Pipeline(Pipeline) + DynamicCapability.Client asCapability"releaseAs< ::capnp::DynamicCapability>"() + cdef extern from "capnp/schema-parser.h" namespace " ::capnp": cdef cppclass ParsedSchema(Schema): ParsedSchema getNested(char * name) except + @@ -297,8 +313,3 @@ cdef extern from "kj/async.h" namespace " ::kj": PyPromise there(PyPromise, PyObject * func) cdef cppclass SimpleEventLoop(EventLoop): pass - -cdef extern from "asyncHelper.h": - PyPromise evalLater(EventLoop &, PyObject * func) - PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) - PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) diff --git a/test/test_capability.capnp b/test/test_capability.capnp index 0bd862f..7d59d8f 100644 --- a/test/test_capability.capnp +++ b/test/test_capability.capnp @@ -35,11 +35,11 @@ interface TestInterface { # grault @2 () -> TestAllTypes; # } -# interface TestPipeline { -# getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); -# testPointers @1 (cap :TestInterface, obj :Object, list :List(TestInterface)) -> (); +interface TestPipeline { + getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); + testPointers @1 (cap :TestInterface, obj :Object, list :List(TestInterface)) -> (); -# struct Box { -# cap @0 :TestInterface; -# } -# } + struct Box { + cap @0 :TestInterface; + } +} diff --git a/test/test_capability.py b/test/test_capability.py index e8dddac..696b713 100644 --- a/test/test_capability.py +++ b/test/test_capability.py @@ -9,10 +9,21 @@ def capability(): return capnp.load(os.path.join(this_dir, 'test_capability.capnp')) class Server: - def foo(self, context): - context.results.x = str(context.params.i * 5 + 1) + def __init__(self, val=1): + self.val = val -def test_basic_client(capability): + def foo(self, context): + context.results.x = str(context.params.i * 5 + self.val) + +class PipelineServer: + def getCap(self, context): + def _then(response): + context.results.s = response.x + '_foo' + context.results.outBox.outCap = Server(100) + + return context.params.inCap.foo(i=context.params.n).then(_then) + +def test_client(capability): loop = capnp.EventLoop() client = capability.TestInterface.new_client(Server(), loop) @@ -70,3 +81,16 @@ def test_simple_client(capability): with pytest.raises(ValueError): remote = client.foo(baz=5) + +def test_pipeline(capability): + loop = capnp.EventLoop() + + client = capability.TestPipeline.new_client(PipelineServer(), loop) + foo_client = capability.TestInterface.new_client(Server(), loop) + + remote = client.getCap(n=5, inCap=foo_client) + response = loop.wait_remote(remote) + + assert response.s == '26_foo' + + From c3354e90693dc2e65db982c0138d951921cbaa0b Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Sat, 19 Oct 2013 22:38:10 -0700 Subject: [PATCH 14/43] Add ability to pipeline rpc requests --- capnp/capabilityHelper.h | 3 + capnp/capnp.pyx | 104 ++++++++++++++++++++++++++++++++- capnp/capnp_cpp.pxd | 8 ++- examples/example_capability.py | 2 +- test/test_capability.py | 17 +++++- 5 files changed, 127 insertions(+), 7 deletions(-) diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index eee76de..4bb9e40 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -73,6 +73,9 @@ public: capnp::DynamicCapability::Client new_client(capnp::InterfaceSchema & schema, PyObject * server, kj::EventLoop & loop) { return capnp::DynamicCapability::Client(kj::heap(schema, server), loop); } +capnp::DynamicValue::Reader new_server(capnp::InterfaceSchema & schema, PyObject * server) { + return capnp::DynamicValue::Reader(kj::heap(schema, server)); +} ::kj::Promise convert_to_pypromise(capnp::RemotePromise & promise) { return promise.then([](capnp::Response&& response) { return wrap_dynamic_struct_reader(response); } ); diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index fd4b647..48ae123 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr, DynamicCapability as C_DynamicCapability, new_client, Request, Response, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, VoidPromise, CallContext +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr, DynamicCapability as C_DynamicCapability, new_client, new_server, Request, Response, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, VoidPromise, CallContext from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -113,6 +113,7 @@ cdef extern from "capnp/list.h" namespace " ::capnp": uint size() cdef extern from "" namespace "std": + C_DynamicStruct.Pipeline moveStructPipeline"std::move"(C_DynamicStruct.Pipeline) C_DynamicOrphan moveOrphan"std::move"(C_DynamicOrphan) Request moveRequest"std::move"(Request) Response moveResponse"std::move"(Response) @@ -375,6 +376,17 @@ cdef class _List_NestedNode_Reader: def __len__(self): return self.thisptr.size() +# cdef to_python_pipeline(C_DynamicValue.Pipeline self, object parent): +# cdef int type = self.getType() +# if type == capnp.TYPE_CAPABILITY: +# return _DynamicCapabilityClient()._init(self.asCapability(), parent) +# # elif type == capnp.TYPE_STRUCT: +# # return _DynamicStructReader()._init(self.asStruct(), parent) +# elif type == capnp.TYPE_UNKNOWN: +# raise ValueError("Cannot convert type to Python. Type is unknown by capnproto library") +# else: +# raise ValueError("Cannot convert type to Python. Type is unhandled by capnproto library") + cdef to_python_reader(C_DynamicValue.Reader self, object parent): cdef int type = self.getType() if type == capnp.TYPE_BOOL: @@ -448,6 +460,9 @@ cdef C_DynamicValue.Reader _extract_dynamic_struct_reader(_DynamicStructReader v cdef C_DynamicValue.Reader _extract_dynamic_client(_DynamicCapabilityClient value): return C_DynamicValue.Reader(value.thisptr) +cdef C_DynamicValue.Reader _extract_dynamic_server(_DynamicCapabilityServer value): + return new_server(value.schema.thisptr, value.server) + cdef _setDynamicField(_DynamicSetterClasses thisptr, field, value, parent): cdef C_DynamicValue.Reader temp value_type = type(value) @@ -480,6 +495,8 @@ cdef _setDynamicField(_DynamicSetterClasses thisptr, field, value, parent): thisptr.set(field, _extract_dynamic_struct_reader(value)) elif value_type is _DynamicCapabilityClient: thisptr.set(field, _extract_dynamic_client(value)) + elif value_type is _DynamicCapabilityServer: + thisptr.set(field, _extract_dynamic_server(value)) else: raise ValueError("Non primitive type") @@ -836,6 +853,53 @@ cdef class _DynamicStructBuilder: def to_dict(self): return _to_dict(self) +cdef class _DynamicStructPipeline: + """Reads Cap'n Proto structs + + This class is almost a 1 for 1 wrapping of the Cap'n Proto C++ DynamicStruct::Pipeline. The only difference is that instead of a `get` method, __getattr__ is overloaded and the field name is passed onto the C++ equivalent `get`. This means you just use . syntax to access any field. For field names that don't follow valid python naming convention for fields, use the global function :py:func:`getattr`:: + """ + cdef C_DynamicStruct.Pipeline * thisptr + cdef public object _parent + + cdef _init(self, C_DynamicStruct.Pipeline * other, object parent): + self.thisptr = other + self._parent = parent + return self + + def __dealloc__(self): + del self.thisptr + + cpdef _get(self, field) except +ValueError: + cdef int type = (self.thisptr.get(field)).getType() + if type == capnp.TYPE_CAPABILITY: + return _DynamicCapabilityClient()._init((self.thisptr.get(field)).asCapability(), self._parent) + elif type == capnp.TYPE_STRUCT: + return _DynamicStructPipeline()._init(new C_DynamicStruct.Pipeline(moveStructPipeline((self.thisptr.get(field)).asStruct())), self._parent) + elif type == capnp.TYPE_UNKNOWN: + raise ValueError("Cannot convert type to Python. Type is unknown by capnproto library") + else: + raise ValueError("Cannot convert type to Python. Type is unhandled by capnproto library") + + def __getattr__(self, field): + return self._get(field) + + property schema: + """A property that returns the _StructSchema object matching this reader""" + def __get__(self): + return _StructSchema()._init(self.thisptr.getSchema()) + + def __dir__(self): + return list(self.schema.fieldnames) + + # def __str__(self): + # return printStructReader(self.thisptr).flatten().cStr() + + # def __repr__(self): + # return '<%s reader %s>' % (self.schema.node.displayName, strStructReader(self.thisptr).cStr()) + + def to_dict(self): + return _to_dict(self) + cdef class _DynamicOrphan: cdef C_DynamicOrphan thisptr cdef public object _parent @@ -1024,7 +1088,15 @@ cdef class _RemotePromise: return _VoidPromise()._init(capnp.then(deref(self.thisptr), func, error_func)) cpdef _get(self, field) except +ValueError: - return _DynamicCapabilityClient()._init((self.thisptr.get(field)).asCapability(), self._parent) + cdef int type = (self.thisptr.get(field)).getType() + if type == capnp.TYPE_CAPABILITY: + return _DynamicCapabilityClient()._init((self.thisptr.get(field)).asCapability(), self._parent) + elif type == capnp.TYPE_STRUCT: + return _DynamicStructPipeline()._init(new C_DynamicStruct.Pipeline(moveStructPipeline((self.thisptr.get(field)).asStruct())), self._parent) + elif type == capnp.TYPE_UNKNOWN: + raise ValueError("Cannot convert type to Python. Type is unknown by capnproto library") + else: + raise ValueError("Cannot convert type to Python. Type is unhandled by capnproto library") def __getattr__(self, field): return self._get(field) @@ -1037,6 +1109,15 @@ cdef class _RemotePromise: def __dir__(self): return list(self.schema.fieldnames) + # def __str__(self): + # return printStructReader(self.thisptr).flatten().cStr() + + # def __repr__(self): + # return '<%s reader %s>' % (self.schema.node.displayName, strStructReader(self.thisptr).cStr()) + + def to_dict(self): + return _to_dict(self) + cdef class EventLoop: cdef SimpleEventLoop thisptr cpdef evalLater(self, func): @@ -1084,6 +1165,20 @@ cdef class _Response(_DynamicStructReader): self._init(deref(self.thisptr_child), parent) return self +cdef class _DynamicCapabilityServer: + cdef public _InterfaceSchema schema + cdef public object server + + def __init__(self, schema, server): + cdef _InterfaceSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + + self.schema = s + self.server = server + cdef class _DynamicCapabilityClient: cdef C_DynamicCapability.Client thisptr cdef public object _event_loop, _server, _parent @@ -1371,8 +1466,13 @@ cdef class SchemaParser: def helper(server, loop): return _DynamicCapabilityClient()._init_vals(bound_local_module, server, loop) return helper + def new_server(bound_local_module): + def helper(server): + return _DynamicCapabilityServer(bound_local_module, server) + return helper local_module.schema = schema.as_interface() local_module.new_client = new_client(local_module) + local_module.new_server = new_server(local_module) _load(schema, local_module) if not _os.path.isfile(file_name): diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index 077d2d5..33b8a9f 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -150,6 +150,8 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": DynamicOrphan disown(char *) DynamicStruct.Reader asReader() cppclass Pipeline: + Pipeline() + Pipeline(Pipeline &) DynamicValueForward.Pipeline get(char *) StructSchema getSchema() @@ -199,8 +201,9 @@ cdef extern from "capabilityHelper.h": PyPromise then(PyPromise & promise, PyObject * func, PyObject * error_func) VoidPromise then(RemotePromise & promise, PyObject * func, PyObject * error_func) cppclass PythonInterfaceDynamicImpl: - pass + PythonInterfaceDynamicImpl(PyObject *) DynamicCapability.Client new_client(InterfaceSchema&, PyObject *, EventLoop&) + DynamicValueForward.Reader new_server(InterfaceSchema&, PyObject *) PyPromise convert_to_pypromise(RemotePromise&) cdef extern from "capnp/dynamic.h" namespace " ::capnp": @@ -245,6 +248,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": Reader(DynamicEnum value) Reader(DynamicStruct.Reader& value) Reader(DynamicCapability.Client& value) + Reader(PythonInterfaceDynamicImpl& value) Type getType() int64_t asInt"as"() uint64_t asUint"as"() @@ -275,6 +279,8 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": cppclass Pipeline: Pipeline(Pipeline) DynamicCapability.Client asCapability"releaseAs< ::capnp::DynamicCapability>"() + DynamicStruct.Pipeline asStruct"releaseAs< ::capnp::DynamicStruct>"() + Type getType() cdef extern from "capnp/schema-parser.h" namespace " ::capnp": cdef cppclass ParsedSchema(Schema): diff --git a/examples/example_capability.py b/examples/example_capability.py index 42c40c3..23059bd 100644 --- a/examples/example_capability.py +++ b/examples/example_capability.py @@ -12,7 +12,7 @@ def example_client(): client = example_capability_capnp.TestInterface.new_client(Server(), loop) - req = client.request('foo') + req = client._request('foo') req.i = 5 remote = req.send() diff --git a/test/test_capability.py b/test/test_capability.py index 696b713..cdad541 100644 --- a/test/test_capability.py +++ b/test/test_capability.py @@ -16,10 +16,13 @@ class Server: context.results.x = str(context.params.i * 5 + self.val) class PipelineServer: + def __init__(self, capability): + self.capability = capability + def getCap(self, context): def _then(response): context.results.s = response.x + '_foo' - context.results.outBox.outCap = Server(100) + context.results.outBox.cap = self.capability.TestInterface.new_server(Server(100)) return context.params.inCap.foo(i=context.params.n).then(_then) @@ -85,12 +88,20 @@ def test_simple_client(capability): def test_pipeline(capability): loop = capnp.EventLoop() - client = capability.TestPipeline.new_client(PipelineServer(), loop) + client = capability.TestPipeline.new_client(PipelineServer(capability), loop) foo_client = capability.TestInterface.new_client(Server(), loop) remote = client.getCap(n=5, inCap=foo_client) - response = loop.wait_remote(remote) + outCap = remote.outBox.cap + pipelinePromise = outCap.foo(i=10) + + response = loop.wait_remote(pipelinePromise) + assert response.x == '150' + + response = loop.wait_remote(remote) assert response.s == '26_foo' + + From a9ad0e6b8557f101f2b4eb6266910fe1ec102332 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Sat, 19 Oct 2013 22:40:55 -0700 Subject: [PATCH 15/43] Make test simpler --- test/test_capability.py | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/test/test_capability.py b/test/test_capability.py index cdad541..e08fb31 100644 --- a/test/test_capability.py +++ b/test/test_capability.py @@ -16,13 +16,10 @@ class Server: context.results.x = str(context.params.i * 5 + self.val) class PipelineServer: - def __init__(self, capability): - self.capability = capability - def getCap(self, context): def _then(response): context.results.s = response.x + '_foo' - context.results.outBox.cap = self.capability.TestInterface.new_server(Server(100)) + context.results.outBox.cap = capability().TestInterface.new_server(Server(100)) return context.params.inCap.foo(i=context.params.n).then(_then) @@ -88,7 +85,7 @@ def test_simple_client(capability): def test_pipeline(capability): loop = capnp.EventLoop() - client = capability.TestPipeline.new_client(PipelineServer(capability), loop) + client = capability.TestPipeline.new_client(PipelineServer(), loop) foo_client = capability.TestInterface.new_client(Server(), loop) remote = client.getCap(n=5, inCap=foo_client) @@ -101,7 +98,3 @@ def test_pipeline(capability): response = loop.wait_remote(remote) assert response.s == '26_foo' - - - - From 5e00534842817beac08ac6c28ac9a43af2753172 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Sun, 20 Oct 2013 17:24:59 -0700 Subject: [PATCH 16/43] Fixup exception handling for capabilities --- capnp/capabilityHelper.h | 34 ++++++++++++++++-- capnp/capnp.pyx | 15 +++++--- examples/example_capability.capnp | 20 +++++------ test/test_capability.py | 57 +++++++++++++++++++++++++++++++ 4 files changed, 110 insertions(+), 16 deletions(-) diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index 4bb9e40..b81a50a 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -13,9 +13,27 @@ extern "C" { PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { PyObject * result = PyObject_CallFunctionObjArgs(func, arg, NULL); Py_DECREF(func); + + PyObject * err = PyErr_Occurred(); + if(err) { + char * errorMsg = PyString_AsString(PyObject_Repr(err)); + // PyErr_Clear(); + throw std::invalid_argument(errorMsg); + } return result; } +void wrapRemoteCall(PyObject * func, capnp::Response & arg) { + wrap_remote_call(func, arg); + + PyObject * err = PyErr_Occurred(); + if(err) { + char * errorMsg = PyString_AsString(PyObject_Repr(err)); + // PyErr_Clear(); + throw std::invalid_argument(errorMsg); + } +} + ::kj::Promise evalLater(kj::EventLoop & loop, PyObject * func) { return loop.evalLater([func]() { return wrapPyFunc(func, NULL); } ); } @@ -38,9 +56,9 @@ PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { ::kj::Promise then(::capnp::RemotePromise< ::capnp::DynamicStruct> & promise, PyObject * func, PyObject * error_func) { if(error_func == Py_None) - return promise.then([func](capnp::Response&& arg) { wrap_remote_call(func, arg); } ); + return promise.then([func](capnp::Response&& arg) { wrapRemoteCall(func, arg); } ); else - return promise.then([func](capnp::Response&& arg) { wrap_remote_call(func, arg); } + return promise.then([func](capnp::Response&& arg) { wrapRemoteCall(func, arg); } , [error_func](kj::Exception arg) { wrapPyFunc(error_func, wrap_kj_exception(arg)); } ); } @@ -60,7 +78,19 @@ public: kj::Promise call(capnp::InterfaceSchema::Method method, capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> context) { auto methodName = method.getProto().getName(); + kj::Promise * promise = call_server_method(py_server, const_cast(methodName.cStr()), context); + + PyObject * err = PyErr_Occurred(); + if(err) { + PyObject *ptype, *pvalue, *ptraceback; + PyErr_Fetch(&ptype, &pvalue, &ptraceback); + + char * errorMsg = PyString_AsString(pvalue); + PyErr_Clear(); + throw std::invalid_argument(errorMsg); + } + if(promise == nullptr) return kj::READY_NOW; diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 48ae123..fbc51d2 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -39,30 +39,37 @@ import os as _os import sys as _sys import imp as _imp from functools import partial as _partial +import warnings as _warnings +import inspect as _inspect # By making it public, we'll be able to call it from capabilityHelper.h cdef public object wrap_dynamic_struct_reader(C_DynamicStruct.Reader & reader): return _DynamicStructReader()._init(reader, None) -cdef public void wrap_remote_call(PyObject * func, Response & r): +cdef public void wrap_remote_call(PyObject * func, Response & r) except *: response = _Response()._init_childptr(new Response(moveResponse(r)), None) func_obj = func # TODO: decref func? func_obj(response) -cdef public VoidPromise * call_server_method(PyObject * _server, char * _method_name, CallContext & _context): +cdef public VoidPromise * call_server_method(PyObject * _server, char * _method_name, CallContext & _context) except *: server = _server method_name = _method_name context = _CallContext()._init(_context) - ret = getattr(server, method_name)(context) + func = getattr(server, method_name) + ret = func(context) if ret is not None: if type(ret) is _VoidPromise: return new VoidPromise(moveVoidPromise(deref((<_VoidPromise>ret).thisptr))) else: - raise ValueError('Server function returned a value that was not a VoidPromise: ' + str(ret)) + try: + warning_msg = 'Server function (%s) returned a value that was not a VoidPromise: return = %s' % (method_name, str(ret)) + except: + warning_msg = 'Server function (%s) returned a value that was not a VoidPromise' % (method_name) + _warnings.warn_explicit(warning_msg, UserWarning, _inspect.getsourcefile(func), _inspect.getsourcelines(func)[1]) return NULL diff --git a/examples/example_capability.capnp b/examples/example_capability.capnp index 0bd862f..b947bda 100644 --- a/examples/example_capability.capnp +++ b/examples/example_capability.capnp @@ -29,17 +29,17 @@ interface TestInterface { # baz @2 (s: TestAllTypes); } -# interface TestExtends extends(TestInterface) { -# qux @0 (); +interface TestExtends extends(TestInterface) { + qux @0 (); # corge @1 TestAllTypes -> (); # grault @2 () -> TestAllTypes; -# } +} -# interface TestPipeline { -# getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); -# testPointers @1 (cap :TestInterface, obj :Object, list :List(TestInterface)) -> (); +interface TestPipeline { + getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); + testPointers @1 (cap :TestInterface, obj :Object, list :List(TestInterface)) -> (); -# struct Box { -# cap @0 :TestInterface; -# } -# } + struct Box { + cap @0 :TestInterface; + } +} diff --git a/test/test_capability.py b/test/test_capability.py index e08fb31..4352afc 100644 --- a/test/test_capability.py +++ b/test/test_capability.py @@ -98,3 +98,60 @@ def test_pipeline(capability): response = loop.wait_remote(remote) assert response.s == '26_foo' + +class BadServer: + def __init__(self, val=1): + self.val = val + + def foo(self, context): + context.results.x = str(context.params.i * 5 + self.val) + context.results.x2 = 5 # raises exception + +def test_exception_client(capability): + loop = capnp.EventLoop() + + client = capability.TestInterface.new_client(BadServer(), loop) + + remote = client._send('foo', i=5) + with pytest.raises(RuntimeError): + loop.wait_remote(remote) + +class BadPipelineServer: + def getCap(self, context): + def _then(response): + context.results.s = response.x + '_foo' + context.results.outBox.cap = capability().TestInterface.new_server(Server(100)) + def _error(error): + raise Exception('test') + + return context.params.inCap.foo(i=context.params.n).then(_then, _error) + +def test_exception_chain(capability): + loop = capnp.EventLoop() + + client = capability.TestPipeline.new_client(BadPipelineServer(), loop) + foo_client = capability.TestInterface.new_client(BadServer(), loop) + + remote = client.getCap(n=5, inCap=foo_client) + + try: + loop.wait_remote(remote) + except Exception as e: + assert e.message == 'test' + +def test_pipeline_exception(capability): + loop = capnp.EventLoop() + + client = capability.TestPipeline.new_client(BadPipelineServer(), loop) + foo_client = capability.TestInterface.new_client(BadServer(), loop) + + remote = client.getCap(n=5, inCap=foo_client) + + outCap = remote.outBox.cap + pipelinePromise = outCap.foo(i=10) + + with pytest.raises(Exception): + loop.wait_remote(pipelinePromise) + + with pytest.raises(Exception): + loop.wait_remote(remote) From d7abfae1ed7d8e977b2567db0384e80cc8ce09f1 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Sun, 20 Oct 2013 18:46:41 -0700 Subject: [PATCH 17/43] Cleanup exception handling --- capnp/capabilityHelper.h | 32 +++++++++++--------------------- test/test_capability.py | 4 ++-- 2 files changed, 13 insertions(+), 23 deletions(-) diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index b81a50a..0c9023a 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -10,28 +10,26 @@ extern "C" { PyObject * wrap_kj_exception(kj::Exception &); } +void check_py_error() { + PyObject * err = PyErr_Occurred(); + if(err) { + // PyErr_Clear(); + throw std::exception(); + } +} + PyObject * wrapPyFunc(PyObject * func, PyObject * arg) { PyObject * result = PyObject_CallFunctionObjArgs(func, arg, NULL); Py_DECREF(func); - PyObject * err = PyErr_Occurred(); - if(err) { - char * errorMsg = PyString_AsString(PyObject_Repr(err)); - // PyErr_Clear(); - throw std::invalid_argument(errorMsg); - } + check_py_error(); return result; } void wrapRemoteCall(PyObject * func, capnp::Response & arg) { wrap_remote_call(func, arg); - PyObject * err = PyErr_Occurred(); - if(err) { - char * errorMsg = PyString_AsString(PyObject_Repr(err)); - // PyErr_Clear(); - throw std::invalid_argument(errorMsg); - } + check_py_error(); } ::kj::Promise evalLater(kj::EventLoop & loop, PyObject * func) { @@ -81,15 +79,7 @@ public: kj::Promise * promise = call_server_method(py_server, const_cast(methodName.cStr()), context); - PyObject * err = PyErr_Occurred(); - if(err) { - PyObject *ptype, *pvalue, *ptraceback; - PyErr_Fetch(&ptype, &pvalue, &ptraceback); - - char * errorMsg = PyString_AsString(pvalue); - PyErr_Clear(); - throw std::invalid_argument(errorMsg); - } + check_py_error(); if(promise == nullptr) return kj::READY_NOW; diff --git a/test/test_capability.py b/test/test_capability.py index 4352afc..857e319 100644 --- a/test/test_capability.py +++ b/test/test_capability.py @@ -113,7 +113,7 @@ def test_exception_client(capability): client = capability.TestInterface.new_client(BadServer(), loop) remote = client._send('foo', i=5) - with pytest.raises(RuntimeError): + with pytest.raises(ValueError): loop.wait_remote(remote) class BadPipelineServer: @@ -137,7 +137,7 @@ def test_exception_chain(capability): try: loop.wait_remote(remote) except Exception as e: - assert e.message == 'test' + assert str(e) == 'test' def test_pipeline_exception(capability): loop = capnp.EventLoop() From f947e3270f0026df43fbb511e6b6266293d1a44c Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Sun, 20 Oct 2013 22:44:15 -0700 Subject: [PATCH 18/43] Add warning when writing the same message more than once --- capnp/capnp.pyx | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index fbc51d2..d68eb5b 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -670,13 +670,20 @@ cdef class _DynamicStructBuilder: """ cdef C_DynamicStruct.Builder thisptr cdef public object _parent - cdef bint _isRoot + cdef bint _is_root, _is_written cdef _init(self, C_DynamicStruct.Builder other, object parent, bint isRoot = False): self.thisptr = other self._parent = parent - self._isRoot = isRoot + self._is_root = isRoot + self._is_written = False return self - + + cdef _check_write(self): + if not self._is_root: + raise ValueError("You can only call write() on the message's root struct.") + if self._is_written: + _warnings.warn("This message has already been written once. Be very careful that you're not setting Text/Struct/List fields more than once, since that will cause memory leaks (both in memory and in the serialized data). You can disable this warning by setting the `_is_written` field of this object to False after every write.") + def write(self, file): """Writes the struct's containing message to the given file object in unpacked binary format. @@ -690,9 +697,9 @@ cdef class _DynamicStructBuilder: :Raises: :exc:`exceptions.ValueError` if this isn't the message's root struct. """ - if not self._isRoot: - raise ValueError("You can only call write() on the message's root struct.") + self._check_write() _write_message_to_fd(file.fileno(), self._parent) + self._is_written = True def write_packed(self, file): """Writes the struct's containing message to the given file object in packed binary format. @@ -707,9 +714,9 @@ cdef class _DynamicStructBuilder: :Raises: :exc:`exceptions.ValueError` if this isn't the message's root struct. """ - if not self._isRoot: - raise ValueError("You can only call write() on the message's root struct.") + self._check_write() _write_packed_message_to_fd(file.fileno(), self._parent) + self._is_written = True def to_bytes(_DynamicStructBuilder self): """Returns the struct's containing message as a Python bytes object in the unpacked binary format. @@ -720,12 +727,12 @@ cdef class _DynamicStructBuilder: :Raises: :exc:`exceptions.ValueError` if this isn't the message's root struct. """ - if not self._isRoot: - raise ValueError("You can only call write() on the message's root struct.") + self._check_write() cdef _MessageBuilder builder = self._parent array = schema_cpp.messageToFlatArray(deref(builder.thisptr)) cdef const char* ptr = array.begin() cdef bytes ret = ptr[:8*array.size()] + self._is_written = True return ret cdef _get(self, field): From 54413dedeb3265a02de390b37cada8ca4abbd19e Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Sun, 20 Oct 2013 22:55:41 -0700 Subject: [PATCH 19/43] Add `as_builder` method to Struct Reader --- capnp/capnp.pyx | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index d68eb5b..a830c4a 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -655,6 +655,16 @@ cdef class _DynamicStructReader: def to_dict(self): return _to_dict(self) + cpdef as_builder(self): + """A method for casting this Builder to a Reader + + Don't use this method unless you know what you're doing. + + :rtype: :class:`_DynamicStructReader` + """ + builder = _MallocMessageBuilder() + return builder.set_root(self) + cdef class _DynamicStructBuilder: """Builds Cap'n Proto structs From 105450906badc2e5e7a659303fdadecc058801ac Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Mon, 21 Oct 2013 00:11:42 -0700 Subject: [PATCH 20/43] Fix build for clang/python3. Also remove -fpermissive --- capnp/capnp.pyx | 40 ++++++++++++++++++++-------------------- capnp/capnp_cpp.pxd | 4 ++-- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index a830c4a..e334f7e 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -1,6 +1,6 @@ # capnp.pyx # distutils: language = c++ -# distutils: extra_compile_args = --std=c++11 -fpermissive +# distutils: extra_compile_args = --std=c++11 # distutils: libraries = capnpc capnp # cython: c_string_type = str # cython: c_string_encoding = default @@ -151,7 +151,7 @@ cdef class _NodeReader: property displayName: def __get__(self): - return self.thisptr.getDisplayName().cStr() + return self.thisptr.getDisplayName().cStr() property scopeId: def __get__(self): return self.thisptr.getScopeId() @@ -179,7 +179,7 @@ cdef class _NestedNodeReader: property name: def __get__(self): - return self.thisptr.getName().cStr() + return self.thisptr.getName().cStr() property id: def __get__(self): return self.thisptr.getId() @@ -218,11 +218,11 @@ cdef class _DynamicListReader: return self.thisptr.size() def __str__(self): - return printListReader(self.thisptr).flatten().cStr() + return printListReader(self.thisptr).flatten().cStr() def __repr__(self): # TODO: Print the list type. - return '' % strListReader(self.thisptr).cStr() + return '' % strListReader(self.thisptr).cStr() cdef class _DynamicResizableListBuilder: """Class for building growable Cap'n Proto Lists @@ -361,11 +361,11 @@ cdef class _DynamicListBuilder: return _DynamicOrphan()._init(self.thisptr.disown(index), self._parent) def __str__(self): - return printListBuilder(self.thisptr).flatten().cStr() + return printListBuilder(self.thisptr).flatten().cStr() def __repr__(self): # TODO: Print the list type. - return '' % strListBuilder(self.thisptr).cStr() + return '' % strListBuilder(self.thisptr).cStr() cdef class _List_NestedNode_Reader: cdef List[C_Node.NestedNode].Reader thisptr @@ -405,7 +405,7 @@ cdef to_python_reader(C_DynamicValue.Reader self, object parent): elif type == capnp.TYPE_FLOAT: return self.asDouble() elif type == capnp.TYPE_TEXT: - return self.asText()[:] + return (self.asText().cStr())[:] elif type == capnp.TYPE_DATA: temp = self.asData() return (temp.begin())[:temp.size()] @@ -414,7 +414,7 @@ cdef to_python_reader(C_DynamicValue.Reader self, object parent): elif type == capnp.TYPE_STRUCT: return _DynamicStructReader()._init(self.asStruct(), parent) elif type == capnp.TYPE_ENUM: - return fixMaybe(self.asEnum().getEnumerant()).getProto().getName().cStr() + return fixMaybe(self.asEnum().getEnumerant()).getProto().getName().cStr() elif type == capnp.TYPE_VOID: return None elif type == capnp.TYPE_OBJECT: @@ -437,7 +437,7 @@ cdef to_python_builder(C_DynamicValue.Builder self, object parent): elif type == capnp.TYPE_FLOAT: return self.asDouble() elif type == capnp.TYPE_TEXT: - return self.asText()[:] + return (self.asText().cStr())[:] elif type == capnp.TYPE_DATA: temp = self.asData() return (temp.begin())[:temp.size()] @@ -446,7 +446,7 @@ cdef to_python_builder(C_DynamicValue.Builder self, object parent): elif type == capnp.TYPE_STRUCT: return _DynamicStructBuilder()._init(self.asStruct(), parent) elif type == capnp.TYPE_ENUM: - return fixMaybe(self.asEnum().getEnumerant()).getProto().getName().cStr() + return fixMaybe(self.asEnum().getEnumerant()).getProto().getName().cStr() elif type == capnp.TYPE_VOID: return None elif type == capnp.TYPE_OBJECT: @@ -632,7 +632,7 @@ cdef class _DynamicStructReader: :Raises: :exc:`exceptions.ValueError` if this struct doesn't contain a union """ - cdef object which = getEnumString(self.thisptr) + cdef object which = getEnumString(self.thisptr) if len(which) == 0: raise ValueError("Attempted to call which on a non-union type") @@ -647,10 +647,10 @@ cdef class _DynamicStructReader: return list(self.schema.fieldnames) def __str__(self): - return printStructReader(self.thisptr).flatten().cStr() + return printStructReader(self.thisptr).flatten().cStr() def __repr__(self): - return '<%s reader %s>' % (self.schema.node.displayName, strStructReader(self.thisptr).cStr()) + return '<%s reader %s>' % (self.schema.node.displayName, strStructReader(self.thisptr).cStr()) def to_dict(self): return _to_dict(self) @@ -814,7 +814,7 @@ cdef class _DynamicStructBuilder: :Raises: :exc:`exceptions.ValueError` if this struct doesn't contain a union """ - cdef object which = getEnumString(self.thisptr) + cdef object which = getEnumString(self.thisptr) if len(which) == 0: raise ValueError("Attempted to call which on a non-union type") @@ -869,10 +869,10 @@ cdef class _DynamicStructBuilder: return list(self.schema.fieldnames) def __str__(self): - return printStructBuilder(self.thisptr).flatten().cStr() + return printStructBuilder(self.thisptr).flatten().cStr() def __repr__(self): - return '<%s builder %s>' % (self.schema.node.displayName, strStructBuilder(self.thisptr).cStr()) + return '<%s builder %s>' % (self.schema.node.displayName, strStructBuilder(self.thisptr).cStr()) def to_dict(self): return _to_dict(self) @@ -1286,7 +1286,7 @@ cdef class _StructSchema: return self.__fieldnames fieldlist = self.thisptr.getFields() nfields = fieldlist.size() - self.__fieldnames = tuple(fieldlist[i].getProto().getName().cStr() + self.__fieldnames = tuple(fieldlist[i].getProto().getName().cStr() for i in xrange(nfields)) return self.__fieldnames @@ -1297,7 +1297,7 @@ cdef class _StructSchema: return self.__union_fields fieldlist = self.thisptr.getUnionFields() nfields = fieldlist.size() - self.__union_fields = tuple(fieldlist[i].getProto().getName().cStr() + self.__union_fields = tuple(fieldlist[i].getProto().getName().cStr() for i in xrange(nfields)) return self.__union_fields @@ -1308,7 +1308,7 @@ cdef class _StructSchema: return self.__non_union_fields fieldlist = self.thisptr.getNonUnionFields() nfields = fieldlist.size() - self.__non_union_fields = tuple(fieldlist[i].getProto().getName().cStr() + self.__non_union_fields = tuple(fieldlist[i].getProto().getName().cStr() for i in xrange(nfields)) return self.__non_union_fields diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index 33b8a9f..9791de2 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -254,7 +254,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": uint64_t asUint"as"() bint asBool"as"() double asDouble"as"() - char * asText"as< ::capnp::Text>().cStr"() + String asText"as< ::capnp::Text>"() DynamicList.Reader asList"as< ::capnp::DynamicList>"() DynamicStruct.Reader asStruct"as< ::capnp::DynamicStruct>"() ObjectPointer.Reader asObject"as< ::capnp::ObjectPointer>"() @@ -268,7 +268,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": uint64_t asUint"as"() bint asBool"as"() double asDouble"as"() - char * asText"as< ::capnp::Text>().cStr"() + String asText"as< ::capnp::Text>"() DynamicList.Builder asList"as< ::capnp::DynamicList>"() DynamicStruct.Builder asStruct"as< ::capnp::DynamicStruct>"() ObjectPointer.Builder asObject"as< ::capnp::ObjectPointer>"() From 0498d046328619ab3fbcee61706b5fa071e05411 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 22 Oct 2013 13:22:08 -0700 Subject: [PATCH 21/43] Add capnp-json serializer script. Also fix bugs in from_dict --- capnp/capnp.pyx | 11 ++++++++++- scripts/capnp-json.py | 43 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 1 deletion(-) create mode 100644 scripts/capnp-json.py diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index e334f7e..23a4458 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -568,7 +568,15 @@ import collections as _collections cdef _from_dict_helper(msg, field, d): d_type = type(d) if d_type is dict: - sub_msg = getattr(msg, field) + try: + sub_msg = getattr(msg, field) + except Exception as e: + str_error = str(e) + if 'expected isSetInUnion(field)' in str_error: + msg.init(field) + sub_msg = getattr(msg, field) + else: + raise for key, val in d.iteritems(): if key != 'which': _from_dict_helper(sub_msg, key, val) @@ -584,6 +592,7 @@ cdef _from_dict_helper(msg, field, d): else: setattr(msg, field, d) + cdef _from_dict(msg, d): for key, val in d.iteritems(): if key != 'which': diff --git a/scripts/capnp-json.py b/scripts/capnp-json.py new file mode 100644 index 0000000..ec4eb08 --- /dev/null +++ b/scripts/capnp-json.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python + +import argparse +import sys +import json +import capnp + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument("command") + parser.add_argument("schema_file") + parser.add_argument("struct_name") + + return parser.parse_args() + +def encode(schema_file, struct_name): + schema = capnp.load(schema_file) + + struct_schema = getattr(schema, struct_name) + + struct_dict = json.load(sys.stdin) + struct = struct_schema.from_dict(struct_dict) + + struct.write(sys.stdout) + +def decode(schema_file, struct_name): + schema = capnp.load(schema_file) + + struct_schema = getattr(schema, struct_name) + struct = struct_schema.read(sys.stdin) + + json.dump(struct.to_dict(), sys.stdout) + +def main(): + args = parse_args() + + command = args.command + kwargs = vars(args) + del kwargs['command'] + + globals()[command](**kwargs) # hacky way to get defined functions, and call function with name=command + +main() \ No newline at end of file From e28a9e660191a2a4f9742630c81a4557bd0eee3a Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 22 Oct 2013 13:32:35 -0700 Subject: [PATCH 22/43] Add defaults flag to capnp-json. Also remove 'which' field --- capnp/capnp.pyx | 34 +++++++++++++++------------------- scripts/capnp-json.py | 7 ++++--- 2 files changed, 19 insertions(+), 22 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 23a4458..be014ed 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -542,29 +542,27 @@ cdef _setDynamicFieldPtr(_DynamicSetterClasses * thisptr, field, value, parent): else: raise ValueError("Non primitive type") -cdef _to_dict(msg): +cdef _to_dict(msg, bint verbose): msg_type = type(msg) if msg_type is _DynamicListBuilder or msg_type is _DynamicListReader or msg_type is _DynamicResizableListBuilder: - return [_to_dict(x) for x in msg] + return [_to_dict(x, verbose) for x in msg] if msg_type is _DynamicStructBuilder or msg_type is _DynamicStructReader: ret = {} try: which = msg.which() - ret['which'] = which - ret[which] = _to_dict(getattr(msg, which)) + ret[which] = _to_dict(getattr(msg, which), verbose) except ValueError: pass for field in msg.schema.non_union_fields: - if msg._has(field): - ret[field] = _to_dict(getattr(msg, field)) + if verbose or msg._has(field): + ret[field] = _to_dict(getattr(msg, field), verbose) return ret return msg -import collections as _collections cdef _from_dict_helper(msg, field, d): d_type = type(d) if d_type is dict: @@ -578,15 +576,13 @@ cdef _from_dict_helper(msg, field, d): else: raise for key, val in d.iteritems(): - if key != 'which': - _from_dict_helper(sub_msg, key, val) + _from_dict_helper(sub_msg, key, val) elif d_type is list and len(d) > 0: l = msg.init(field, len(d)) for i in range(len(d)): if isinstance(d[i], (dict, list)): for key, val in d[i].iteritems(): - if key != 'which': - _from_dict_helper(l[i], key, val) + _from_dict_helper(l[i], key, val) else: l[i] = d[i] else: @@ -661,8 +657,8 @@ cdef class _DynamicStructReader: def __repr__(self): return '<%s reader %s>' % (self.schema.node.displayName, strStructReader(self.thisptr).cStr()) - def to_dict(self): - return _to_dict(self) + def to_dict(self, verbose=False): + return _to_dict(self, verbose) cpdef as_builder(self): """A method for casting this Builder to a Reader @@ -883,8 +879,8 @@ cdef class _DynamicStructBuilder: def __repr__(self): return '<%s builder %s>' % (self.schema.node.displayName, strStructBuilder(self.thisptr).cStr()) - def to_dict(self): - return _to_dict(self) + def to_dict(self, verbose=False): + return _to_dict(self, verbose) cdef class _DynamicStructPipeline: """Reads Cap'n Proto structs @@ -930,8 +926,8 @@ cdef class _DynamicStructPipeline: # def __repr__(self): # return '<%s reader %s>' % (self.schema.node.displayName, strStructReader(self.thisptr).cStr()) - def to_dict(self): - return _to_dict(self) + def to_dict(self, verbose=False): + return _to_dict(self, verbose) cdef class _DynamicOrphan: cdef C_DynamicOrphan thisptr @@ -1148,8 +1144,8 @@ cdef class _RemotePromise: # def __repr__(self): # return '<%s reader %s>' % (self.schema.node.displayName, strStructReader(self.thisptr).cStr()) - def to_dict(self): - return _to_dict(self) + def to_dict(self, verbose=False): + return _to_dict(self, verbose) cdef class EventLoop: cdef SimpleEventLoop thisptr diff --git a/scripts/capnp-json.py b/scripts/capnp-json.py index ec4eb08..f41a05e 100644 --- a/scripts/capnp-json.py +++ b/scripts/capnp-json.py @@ -10,10 +10,11 @@ def parse_args(): parser.add_argument("command") parser.add_argument("schema_file") parser.add_argument("struct_name") + parser.add_argument("-d", "--defaults", help="include default values in json output", action="store_true") return parser.parse_args() -def encode(schema_file, struct_name): +def encode(schema_file, struct_name, **kwargs): schema = capnp.load(schema_file) struct_schema = getattr(schema, struct_name) @@ -23,13 +24,13 @@ def encode(schema_file, struct_name): struct.write(sys.stdout) -def decode(schema_file, struct_name): +def decode(schema_file, struct_name, defaults): schema = capnp.load(schema_file) struct_schema = getattr(schema, struct_name) struct = struct_schema.read(sys.stdin) - json.dump(struct.to_dict(), sys.stdout) + json.dump(struct.to_dict(defaults), sys.stdout) def main(): args = parse_args() From ca88b7de64f1ef1fe848bc95b137b3f020e542c6 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 22 Oct 2013 13:39:01 -0700 Subject: [PATCH 23/43] Make script executable --- scripts/capnp-json.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100644 => 100755 scripts/capnp-json.py diff --git a/scripts/capnp-json.py b/scripts/capnp-json.py old mode 100644 new mode 100755 From 229903b87bc891554d8230f643e8a0f75f7638de Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Mon, 28 Oct 2013 13:41:43 -0700 Subject: [PATCH 24/43] Fix exception handling for reading/writing --- capnp/schema_cpp.pxd | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/capnp/schema_cpp.pxd b/capnp/schema_cpp.pxd index 19a73d8..d3dff2c 100644 --- a/capnp/schema_cpp.pxd +++ b/capnp/schema_cpp.pxd @@ -693,20 +693,20 @@ cdef extern from "capnp/message.h" namespace " ::capnp": cdef extern from "capnp/serialize.h" namespace " ::capnp": cdef cppclass StreamFdMessageReader(MessageReader): - StreamFdMessageReader(int) - StreamFdMessageReader(int, ReaderOptions) + StreamFdMessageReader(int) except + + StreamFdMessageReader(int, ReaderOptions) except + cdef cppclass FlatArrayMessageReader(MessageReader): - FlatArrayMessageReader(capnp_cpp.WordArrayPtr array) - FlatArrayMessageReader(capnp_cpp.WordArrayPtr array, ReaderOptions) + FlatArrayMessageReader(capnp_cpp.WordArrayPtr array) except + + FlatArrayMessageReader(capnp_cpp.WordArrayPtr array, ReaderOptions) except + - void writeMessageToFd(int, MessageBuilder&) + void writeMessageToFd(int, MessageBuilder&) except + capnp_cpp.WordArray messageToFlatArray(MessageBuilder &) cdef extern from "capnp/serialize-packed.h" namespace " ::capnp": cdef cppclass PackedFdMessageReader(MessageReader): - PackedFdMessageReader(int) - StreamFdMessageReader(int, ReaderOptions) + PackedFdMessageReader(int) except + + StreamFdMessageReader(int, ReaderOptions) except + - void writePackedMessageToFd(int, MessageBuilder&) + void writePackedMessageToFd(int, MessageBuilder&) except + From d8bb8206b980fddd65f6c2719515eee679d2bf6e Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 5 Nov 2013 15:37:51 -0800 Subject: [PATCH 25/43] fix up small typos --- capnp/capnp.pyx | 2 +- setup.py | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index be014ed..a40a684 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -1885,7 +1885,7 @@ def add_import_hook(additional_paths=[]): import capnp capnp.add_import_hook() - import addressbook + import addressbook_capnp # equivalent to capnp.load('addressbook.capnp', 'addressbook', sys.path), except it will search for 'addressbook.capnp' in all directories of sys.path :type additional_paths: list diff --git a/setup.py b/setup.py index 95a2fe5..bf2ed7d 100644 --- a/setup.py +++ b/setup.py @@ -11,15 +11,15 @@ if Cython.__version__ < '0.19.1': import pkg_resources setuptools_version = pkg_resources.get_distribution("setuptools").version if setuptools_version < '0.8': - raise RuntimeError('Old setuptools installed (%s). Please run `pip install -U setuptools`. Running `pip install capnp` will not work alone, since setuptools needs to be upgraded before installing anything else.' % setuptools_version) + raise RuntimeError('Old setuptools installed (%s). Please run `pip install -U setuptools`. Running `pip install pycapnp` will not work alone, since setuptools needs to be upgraded before installing anything else.' % setuptools_version) from distutils.core import setup import os MAJOR = 0 -MINOR = 3 -MICRO = 14 -VERSION = '%d.%d.%d' % (MAJOR, MINOR, MICRO) +MINOR = 4 +MICRO = 0 +VERSION = '%d.%d.%d-dev' % (MAJOR, MINOR, MICRO) def write_version_py(filename=None): cnt = """\ @@ -54,7 +54,7 @@ setup( 'cython > 0.19', 'setuptools >= 0.8'], # PyPi info - description='A cython wrapping of the C++ capnproto library', + description="A cython wrapping of the C++ Cap'n Proto library", long_description=long_description, license='BSD', author="Jason Paryani", From 91c1bde8332a42b4177ad36753c152eccd75a076 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Thu, 7 Nov 2013 14:47:13 -0800 Subject: [PATCH 26/43] Fix problems compiling with gcc4.7 --- capnp/capnp.pyx | 4 ++-- capnp/capnp_cpp.pxd | 15 --------------- capnp/schema_cpp.pxd | 25 +++++++++++++++++++++---- 3 files changed, 23 insertions(+), 21 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index a40a684..ccc3fba 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, WordArrayPtr, DynamicCapability as C_DynamicCapability, new_client, new_server, Request, Response, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, VoidPromise, CallContext +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, Request, Response, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, VoidPromise, CallContext from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -1720,7 +1720,7 @@ cdef class _FlatArrayMessageReader(_MessageReader): if sz % 8 != 0: raise ValueError("input length must be a multiple of eight bytes") self._object_to_pin = buf - self.thisptr = new schema_cpp.FlatArrayMessageReader(capnp.WordArrayPtr(ptr, sz//8)) + self.thisptr = new schema_cpp.FlatArrayMessageReader(schema_cpp.WordArrayPtr(ptr, sz//8)) def _write_message_to_fd(int fd, _MessageBuilder message): """Serialize a Cap'n Proto message to a file descriptor diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index 9791de2..cc02e75 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -12,8 +12,6 @@ from libcpp cimport bool as cbool cdef extern from "capnp/common.h" namespace " ::capnp": enum Void: VOID " ::capnp::VOID" - cdef cppclass word: - pass cdef extern from "kj/exception.h" namespace " ::kj": cdef cppclass Exception: @@ -38,23 +36,11 @@ cdef extern from "kj/common.h" namespace " ::kj": size_t size() T& operator[](size_t index) - # Cython can't handle ArrayPtr[word] as a function argument - cdef cppclass WordArrayPtr "::kj::ArrayPtr<::capnp::word>": - WordArrayPtr() - WordArrayPtr(word *, size_t size) - size_t size() - word& operator[](size_t index) - cdef extern from "kj/array.h" namespace " ::kj": cdef cppclass Array[T]: T* begin() size_t size() - # Cython can't handle Array[word] as a function argument - cdef cppclass WordArray "::kj::Array<::capnp::word>": - word* begin() - size_t size() - cdef extern from "capnp/schema.h" namespace " ::capnp": cdef cppclass Schema: Node.Reader getProto() except + @@ -194,7 +180,6 @@ cdef extern from "fixMaybe.h": char * getEnumString(DynamicStruct.Builder val) char * getEnumString(Request val) - cdef extern from "capabilityHelper.h": PyPromise evalLater(EventLoop &, PyObject * func) PyPromise there(EventLoop & loop, PyPromise & promise, PyObject * func, PyObject * error_func) diff --git a/capnp/schema_cpp.pxd b/capnp/schema_cpp.pxd index d3dff2c..bfea2e6 100644 --- a/capnp/schema_cpp.pxd +++ b/capnp/schema_cpp.pxd @@ -5,7 +5,6 @@ from libc.stdint cimport * from capnp_cpp cimport DynamicOrphan -cimport capnp_cpp ctypedef unsigned int uint ctypedef uint8_t UInt8 ctypedef uint16_t UInt16 @@ -691,18 +690,36 @@ cdef extern from "capnp/message.h" namespace " ::capnp": enum Void: VOID +cdef extern from "capnp/common.h" namespace " ::capnp": + cdef cppclass word: + pass + +cdef extern from "kj/common.h" namespace " ::kj": + # Cython can't handle ArrayPtr[word] as a function argument + cdef cppclass WordArrayPtr " ::kj::ArrayPtr< ::capnp::word>": + WordArrayPtr() + WordArrayPtr(word *, size_t size) + size_t size() + word& operator[](size_t index) + +cdef extern from "kj/array.h" namespace " ::kj": + # Cython can't handle Array[word] as a function argument + cdef cppclass WordArray " ::kj::Array< ::capnp::word>": + word* begin() + size_t size() + cdef extern from "capnp/serialize.h" namespace " ::capnp": cdef cppclass StreamFdMessageReader(MessageReader): StreamFdMessageReader(int) except + StreamFdMessageReader(int, ReaderOptions) except + cdef cppclass FlatArrayMessageReader(MessageReader): - FlatArrayMessageReader(capnp_cpp.WordArrayPtr array) except + - FlatArrayMessageReader(capnp_cpp.WordArrayPtr array, ReaderOptions) except + + FlatArrayMessageReader(WordArrayPtr array) except + + FlatArrayMessageReader(WordArrayPtr array, ReaderOptions) except + void writeMessageToFd(int, MessageBuilder&) except + - capnp_cpp.WordArray messageToFlatArray(MessageBuilder &) + WordArray messageToFlatArray(MessageBuilder &) cdef extern from "capnp/serialize-packed.h" namespace " ::capnp": cdef cppclass PackedFdMessageReader(MessageReader): From 1df115d359ee5716298159dea2f6cd3541d65ca8 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 12 Nov 2013 15:32:23 -0800 Subject: [PATCH 27/43] Initial wrapping of rpc-twoparty functionality --- capnp/async_cpp.pxd | 11 ---- capnp/capabilityHelper.h | 8 ++- capnp/capnp.pyx | 103 +++++++++++++++++++++++++++++- capnp/capnp_cpp.pxd | 53 +++++++++++++-- examples/example_capability.capnp | 13 ++++ examples/example_capability.py | 29 ++++++--- test/test_capability.capnp | 13 ++++ 7 files changed, 198 insertions(+), 32 deletions(-) diff --git a/capnp/async_cpp.pxd b/capnp/async_cpp.pxd index 3817010..21d3a8b 100644 --- a/capnp/async_cpp.pxd +++ b/capnp/async_cpp.pxd @@ -16,14 +16,3 @@ cdef extern from "kj/async.h" namespace " ::kj": ctypedef Promise[PyObject *] PyPromise ctypedef Promise[void] VoidPromise - -cdef extern from "kj/async.h" namespace " ::kj": - cdef cppclass EventLoop: - EventLoop() - # Promise[void] yield_end'yield'() - object wait(PyPromise) except+ - object there(PyPromise) except+ - PyPromise evalLater(PyObject * func) - PyPromise there(PyPromise, PyObject * func) - cdef cppclass SimpleEventLoop(EventLoop): - pass \ No newline at end of file diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index 0c9023a..993e031 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -1,3 +1,5 @@ +#pragma once + #include "capnp/dynamic.h" #include #include "Python.h" @@ -97,6 +99,10 @@ capnp::DynamicValue::Reader new_server(capnp::InterfaceSchema & schema, PyObject return capnp::DynamicValue::Reader(kj::heap(schema, server)); } +capnp::Capability::Client server_to_client(capnp::InterfaceSchema & schema, PyObject * server) { + return kj::heap(schema, server); +} + ::kj::Promise convert_to_pypromise(capnp::RemotePromise & promise) { return promise.then([](capnp::Response&& response) { return wrap_dynamic_struct_reader(response); } ); -} \ No newline at end of file +} diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index ccc3fba..f1aea89 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -1,7 +1,7 @@ # capnp.pyx # distutils: language = c++ # distutils: extra_compile_args = --std=c++11 -# distutils: libraries = capnpc capnp +# distutils: libraries = capnpc capnp capnp-rpc # cython: c_string_type = str # cython: c_string_encoding = default # cython: embedsignature = True @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, Request, Response, RemotePromise, convert_to_pypromise, SimpleEventLoop, PyPromise, VoidPromise, CallContext +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, TwoWayPipe as C_TwoWayPipe, newTwoWayPipe, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -73,6 +73,15 @@ cdef public VoidPromise * call_server_method(PyObject * _server, char * _method_ return NULL +cdef public C_Capability.Client * call_py_restorer(PyObject * _restorer, C_DynamicStruct.Reader & _reader) except *: + restorer = _restorer + reader = _DynamicStructReader()._init(_reader, None) + + ret = restorer.restore(reader) + cdef _DynamicCapabilityServer server = ret + + return new C_Capability.Client(server_to_client(server.schema.thisptr, server.server)) + cdef public object wrap_kj_exception(capnp.Exception & exception): return None # TODO @@ -128,6 +137,7 @@ cdef extern from "" namespace "std": VoidPromise moveVoidPromise"std::move"(VoidPromise) RemotePromise moveRemotePromise"std::move"(RemotePromise) CallContext moveCallContext"std::move"(CallContext) + capnp.Own[capnp.AsyncIoStream] moveOwnAsyncIOStream"std::move"(capnp.Own[capnp.AsyncIoStream]) cdef extern from "" namespace " ::capnp": StringTree printStructReader" ::capnp::prettyPrint"(C_DynamicStruct.Reader) @@ -1148,7 +1158,7 @@ cdef class _RemotePromise: return _to_dict(self, verbose) cdef class EventLoop: - cdef SimpleEventLoop thisptr + cdef UnixEventLoop thisptr cpdef evalLater(self, func): Py_INCREF(func) return Promise()._init(capnp.evalLater(self.thisptr, func)) @@ -1253,6 +1263,93 @@ cdef class _DynamicCapabilityClient: return _partial(self._request, short_name) return _partial(self._send, name) +cdef class _CapabilityClient: + cdef C_Capability.Client * thisptr + cdef public object _parent + + cdef _init(self, C_Capability.Client other, object parent): + self.thisptr = new C_Capability.Client(other) + self._parent = parent + return self + + def __dealloc__(self): + del self.thisptr + + cpdef cast_as(self, schema): + cdef _InterfaceSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + return _DynamicCapabilityClient()._init(self.thisptr.castAs(s.thisptr), self._parent) + +cdef class Restorer: + cdef PyRestorer * thisptr + cdef C_StructSchema schema + + cdef public object restore + + def __init__(self, schema, restore_func): + cdef _StructSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + + self.schema = s.thisptr + self.restore = restore_func + self.thisptr = new PyRestorer(self, self.schema) + + def __dealloc__(self): + del self.thisptr + +cdef class _TwoPartyVatNetwork: + cdef C_TwoPartyVatNetwork * thisptr + + cdef _init(self, EventLoop loop, capnp.AsyncIoStream & stream, Side side): + self.thisptr = new C_TwoPartyVatNetwork(loop.thisptr, stream, side) + return self + + def __dealloc__(self): + del self.thisptr + +cdef class RpcClient: + cdef RpcSystem * thisptr + cdef public _TwoPartyVatNetwork network + cdef public object loop + + def __init__(self, EventLoop loop, TwoWayPipe pipe): + self.loop = loop + self.network = _TwoPartyVatNetwork()._init(loop, deref(moveOwnAsyncIOStream(pipe.thisptr.ends[0])), capnp.CLIENT) + self.thisptr = new RpcSystem(makeRpcClient(deref(self.network.thisptr), loop.thisptr)) + + def __dealloc__(self): + del self.thisptr + + cpdef restore(self, _DynamicStructReader objectId) except+: + cdef _MessageBuilder builder = objectId._parent + return _CapabilityClient()._init(restoreHelper(deref(self.thisptr), deref(builder.thisptr)), self) + +cdef class RpcServer: + cdef RpcSystem * thisptr + cdef public _TwoPartyVatNetwork network + cdef public object loop, restorer + + def __init__(self, EventLoop loop, Restorer restorer, TwoWayPipe pipe): + self.loop = loop + self.restorer = restorer + self.network = _TwoPartyVatNetwork()._init(loop, deref(moveOwnAsyncIOStream(pipe.thisptr.ends[1])), capnp.SERVER) + self.thisptr = new RpcSystem(makeRpcServer(deref(self.network.thisptr), deref(restorer.thisptr), loop.thisptr)) + + def __dealloc__(self): + del self.thisptr + +cdef class TwoWayPipe: + cdef C_TwoWayPipe thisptr + + def __init__(self): + self.thisptr = newTwoWayPipe() + cdef class _Schema: cdef C_Schema thisptr cdef _init(self, C_Schema other): diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index cc02e75..e37ea5b 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -1,7 +1,7 @@ # schema.capnp.cpp.pyx # distutils: language = c++ # distutils: extra_compile_args = --std=c++11 -from schema_cpp cimport Node, Data, StructNode, EnumNode +from schema_cpp cimport Node, Data, StructNode, EnumNode, MessageBuilder from async_cpp cimport PyPromise, VoidPromise, Promise from cpython.ref cimport PyObject @@ -41,6 +41,16 @@ cdef extern from "kj/array.h" namespace " ::kj": T* begin() size_t size() +cdef extern from "kj/async-io.h" namespace " ::kj": + cdef cppclass Own[T]: + T& operator*() + + cdef cppclass AsyncIoStream: + pass + cdef cppclass TwoWayPipe: + Own[AsyncIoStream] * ends + TwoWayPipe newTwoWayPipe() + cdef extern from "capnp/schema.h" namespace " ::capnp": cdef cppclass Schema: Node.Reader getProto() except + @@ -141,11 +151,35 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": DynamicValueForward.Pipeline get(char *) StructSchema getSchema() +cdef extern from "capnp/dynamic.h" namespace " ::capnp": + cdef cppclass DynamicCapability: + cppclass Client: + Client() + Client(Client&) + Client upcast(InterfaceSchema requestedSchema) + InterfaceSchema getSchema() + Request newRequest(char * methodName, uint firstSegmentWordSize) + cdef extern from "capnp/capability.h" namespace " ::capnp": cdef cppclass Response" ::capnp::Response< ::capnp::DynamicStruct>"(DynamicStruct.Reader): Response(Response) cdef cppclass RemotePromise" ::capnp::RemotePromise< ::capnp::DynamicStruct>"(Promise[Response], DynamicStruct.Pipeline): RemotePromise(RemotePromise) + cdef cppclass Capability: + cppclass Client: + Client(Client&) + DynamicCapability.Client castAs"castAs< ::capnp::DynamicCapability>"(InterfaceSchema) + +cdef extern from "capnp/rpc-twoparty.h" namespace " ::capnp": + cdef cppclass RpcSystem" ::capnp::RpcSystem": + RpcSystem(RpcSystem&&) + enum Side" ::capnp::rpc::twoparty::Side": + CLIENT" ::capnp::rpc::twoparty::Side::CLIENT" + SERVER" ::capnp::rpc::twoparty::Side::SERVER" + cdef cppclass TwoPartyVatNetwork: + TwoPartyVatNetwork(EventLoop &, AsyncIoStream& stream, Side) + RpcSystem makeRpcServer(TwoPartyVatNetwork&, PyRestorer&, EventLoop&) + RpcSystem makeRpcClient(TwoPartyVatNetwork&, EventLoop&) cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef cppclass Request" ::capnp::Request< ::capnp::DynamicStruct, ::capnp::DynamicStruct>": @@ -160,12 +194,6 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": Maybe[StructSchema.Field] which() RemotePromise send() - cdef cppclass DynamicCapability: - cppclass Client: - Client upcast(InterfaceSchema requestedSchema) - InterfaceSchema getSchema() - Request newRequest(char * methodName, uint firstSegmentWordSize) - cdef extern from "capnp/object.h" namespace " ::capnp": cdef cppclass ObjectPointer: cppclass Reader: @@ -189,8 +217,14 @@ cdef extern from "capabilityHelper.h": PythonInterfaceDynamicImpl(PyObject *) DynamicCapability.Client new_client(InterfaceSchema&, PyObject *, EventLoop&) DynamicValueForward.Reader new_server(InterfaceSchema&, PyObject *) + Capability.Client server_to_client(InterfaceSchema&, PyObject *) PyPromise convert_to_pypromise(RemotePromise&) +cdef extern from "rpcHelper.h": + cdef cppclass PyRestorer: + PyRestorer(PyObject *, StructSchema&) + Capability.Client restoreHelper(RpcSystem&, MessageBuilder&) + cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef cppclass DynamicEnum: uint16_t getRaw() @@ -304,3 +338,8 @@ cdef extern from "kj/async.h" namespace " ::kj": PyPromise there(PyPromise, PyObject * func) cdef cppclass SimpleEventLoop(EventLoop): pass + +cdef extern from "kj/async-unix.h" namespace " ::kj": + cdef cppclass UnixEventLoop(EventLoop): + pass + diff --git a/examples/example_capability.capnp b/examples/example_capability.capnp index b947bda..bb93c1d 100644 --- a/examples/example_capability.capnp +++ b/examples/example_capability.capnp @@ -43,3 +43,16 @@ interface TestPipeline { cap @0 :TestInterface; } } + +struct TestSturdyRefHostId { + host @0 :Text; +} + +struct TestSturdyRefObjectId { + tag @0 :Tag; + enum Tag { + testInterface @0; + testExtends @1; + testPipeline @2; + } +} \ No newline at end of file diff --git a/examples/example_capability.py b/examples/example_capability.py index 23059bd..6812846 100644 --- a/examples/example_capability.py +++ b/examples/example_capability.py @@ -4,21 +4,30 @@ import capnp import example_capability_capnp class Server: + def __init__(self, val=1): + self.val = val + def foo(self, context): - context.results.x = str(context.params.i * 5 + 1) + context.results.x = str(context.params.i * 5 + self.val) + +def test_simple_rpc(): + def _restore(ref_id): + return example_capability_capnp.TestInterface.new_server(Server(100)) -def example_client(): loop = capnp.EventLoop() - - client = example_capability_capnp.TestInterface.new_client(Server(), loop) - req = client._request('foo') - req.i = 5 + pipe = capnp.TwoWayPipe() + restorer = capnp.Restorer(example_capability_capnp.TestSturdyRefObjectId, _restore) + server = capnp.RpcServer(loop, restorer, pipe) + client = capnp.RpcClient(loop, pipe) - remote = req.send() + ref = example_capability_capnp.TestSturdyRefObjectId.new_message() + cap = client.restore(ref.as_reader()) + cap = cap.cast_as(example_capability_capnp.TestInterface) + + remote = cap.foo(i=5) response = loop.wait_remote(remote) - print(response.x) + assert response.x == '125' -if __name__ == '__main__': - example_client() +test_simple_rpc() \ No newline at end of file diff --git a/test/test_capability.capnp b/test/test_capability.capnp index 7d59d8f..8ce0030 100644 --- a/test/test_capability.capnp +++ b/test/test_capability.capnp @@ -43,3 +43,16 @@ interface TestPipeline { cap @0 :TestInterface; } } + +struct TestSturdyRefHostId { + host @0 :Text; +} + +struct TestSturdyRefObjectId { + tag @0 :Tag; + enum Tag { + testInterface @0; + testExtends @1; + testPipeline @2; + } +} \ No newline at end of file From 0329fd17badfc1b8f1657e6b3f99c1f4cd452b41 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 12 Nov 2013 15:55:57 -0800 Subject: [PATCH 28/43] Add forgotten files for RPC --- capnp/rpcHelper.h | 42 ++++++++++++++++++++++++++++++++++++++++++ test/test_rpc.py | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+) create mode 100644 capnp/rpcHelper.h create mode 100644 test/test_rpc.py diff --git a/capnp/rpcHelper.h b/capnp/rpcHelper.h new file mode 100644 index 0000000..1dc18ea --- /dev/null +++ b/capnp/rpcHelper.h @@ -0,0 +1,42 @@ +#pragma once + +#include "capnp/dynamic.h" +#include "capnp/rpc-twoparty.h" +#include "Python.h" +#include "capabilityHelper.h" + +extern "C" { + capnp::Capability::Client * call_py_restorer(PyObject *, capnp::DynamicStruct::Reader &); +} + +class PyRestorer final: public capnp::SturdyRefRestorer { +public: + PyRestorer(PyObject * _py_restorer, capnp::StructSchema& _schema): py_restorer(_py_restorer), schema(_schema) { + // We don't need to incref/decref, since this C++ class will be owned by the Python wrapper class, and we'll make sure the python class doesn't refcount to 0 elsewhere. + // Py_INCREF(py_restorer); + } + + // ~PyRestorer() { + // Py_DECREF(py_restorer); + // } + + capnp::Capability::Client restore(capnp::ObjectPointer::Reader objectId) override { + auto reader = objectId.getAs(schema); + capnp::Capability::Client * ret = call_py_restorer(py_restorer, reader); + check_py_error(); + capnp::Capability::Client stack_ret(*ret); + delete ret; + + return stack_ret; + } + +private: + PyObject * py_restorer; + capnp::StructSchema schema; +}; + +capnp::Capability::Client restoreHelper(capnp::RpcSystem& client, capnp::MessageBuilder & objectId) { capnp::MallocMessageBuilder hostIdMessage(8); + auto hostId = hostIdMessage.initRoot(); + hostId.setSide(capnp::rpc::twoparty::Side::SERVER); + return client.restore(hostId, objectId.getRoot()); +} diff --git a/test/test_rpc.py b/test/test_rpc.py new file mode 100644 index 0000000..c920ff5 --- /dev/null +++ b/test/test_rpc.py @@ -0,0 +1,36 @@ +import pytest +import capnp +import os + +this_dir = os.path.dirname(__file__) + +@pytest.fixture +def capability(): + return capnp.load(os.path.join(this_dir, 'test_capability.capnp')) + +class Server: + def __init__(self, val=1): + self.val = val + + def foo(self, context): + context.results.x = str(context.params.i * 5 + self.val) + +def test_simple_rpc(capability): + def _restore(ref_id): + return capability.TestInterface.new_server(Server(100)) + + loop = capnp.EventLoop() + pipe = capnp.TwoWayPipe() + + restorer = capnp.Restorer(capability.TestSturdyRefObjectId, _restore) + server = capnp.RpcServer(loop, restorer, pipe) + client = capnp.RpcClient(loop, pipe) + + ref = capability.TestSturdyRefObjectId.new_message() + cap = client.restore(ref.as_reader()) + cap = cap.cast_as(capability.TestInterface) + + remote = cap.foo(i=5) + response = loop.wait_remote(remote) + + assert response.x == '125' From 0744d536e072b25e08bc4adcefbd95531712c706 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 12 Nov 2013 16:13:01 -0800 Subject: [PATCH 29/43] Disable `make check` because of a bug that's causing it to fail --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 663186a..b7ee71d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -18,7 +18,7 @@ before_install: --slave /usr/bin/g++ g++ /usr/bin/g++-4.8 --slave /usr/bin/gcov gcov /usr/bin/gcov-4.8 - sudo update-alternatives --quiet --set gcc /usr/bin/gcc-4.8 - - wget https://github.com/kentonv/capnproto/archive/master.zip && unzip master.zip && cd capnproto-master/c++ && ./setup-autotools.sh && autoreconf -i && ./configure && make -j6 check && sudo make install && sudo ldconfig && cd ../.. + - wget https://github.com/kentonv/capnproto/archive/master.zip && unzip master.zip && cd capnproto-master/c++ && ./setup-autotools.sh && autoreconf -i && ./configure && make -j6 && sudo make install && sudo ldconfig && cd ../.. - pip install -U setuptools - pip install cython - pip install pytest From 374f986fa7a1d0f2753a54754e343443630c33e7 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 12 Nov 2013 19:38:34 -0800 Subject: [PATCH 30/43] Add FdAsyncIoStream. Also clean up RPC interface a bit --- capnp/capnp.pyx | 34 ++++++++++++++++++++-------------- capnp/capnp_cpp.pxd | 15 ++++++++------- capnp/rpcHelper.h | 7 +++++++ examples/example_capability.py | 24 ++++++++++++++---------- test/test_rpc.py | 14 +++++++++----- 5 files changed, 58 insertions(+), 36 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index f1aea89..8391a3f 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, TwoWayPipe as C_TwoWayPipe, newTwoWayPipe, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side, AsyncIoStream_wrapFd, AsyncIoStream, Own from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -137,7 +137,7 @@ cdef extern from "" namespace "std": VoidPromise moveVoidPromise"std::move"(VoidPromise) RemotePromise moveRemotePromise"std::move"(RemotePromise) CallContext moveCallContext"std::move"(CallContext) - capnp.Own[capnp.AsyncIoStream] moveOwnAsyncIOStream"std::move"(capnp.Own[capnp.AsyncIoStream]) + Own[AsyncIoStream] moveOwnAsyncIOStream"std::move"(Own[AsyncIoStream]) cdef extern from "" namespace " ::capnp": StringTree printStructReader" ::capnp::prettyPrint"(C_DynamicStruct.Reader) @@ -1306,7 +1306,7 @@ cdef class Restorer: cdef class _TwoPartyVatNetwork: cdef C_TwoPartyVatNetwork * thisptr - cdef _init(self, EventLoop loop, capnp.AsyncIoStream & stream, Side side): + cdef _init(self, EventLoop loop, AsyncIoStream & stream, Side side): self.thisptr = new C_TwoPartyVatNetwork(loop.thisptr, stream, side) return self @@ -1318,37 +1318,43 @@ cdef class RpcClient: cdef public _TwoPartyVatNetwork network cdef public object loop - def __init__(self, EventLoop loop, TwoWayPipe pipe): + def __init__(self, EventLoop loop, FdAsyncIoStream stream): self.loop = loop - self.network = _TwoPartyVatNetwork()._init(loop, deref(moveOwnAsyncIOStream(pipe.thisptr.ends[0])), capnp.CLIENT) + self.network = _TwoPartyVatNetwork()._init(loop, deref(stream.thisptr), capnp.CLIENT) self.thisptr = new RpcSystem(makeRpcClient(deref(self.network.thisptr), loop.thisptr)) def __dealloc__(self): del self.thisptr - cpdef restore(self, _DynamicStructReader objectId) except+: - cdef _MessageBuilder builder = objectId._parent - return _CapabilityClient()._init(restoreHelper(deref(self.thisptr), deref(builder.thisptr)), self) + cpdef restore(self, objectId) except+: + cdef _MessageBuilder builder + cdef _MessageReader reader + try: + builder = objectId._parent + return _CapabilityClient()._init(restoreHelper(deref(self.thisptr), deref(builder.thisptr)), self) + except: + reader = objectId._parent + return _CapabilityClient()._init(restoreHelper(deref(self.thisptr), deref(reader.thisptr)), self) cdef class RpcServer: cdef RpcSystem * thisptr cdef public _TwoPartyVatNetwork network cdef public object loop, restorer - def __init__(self, EventLoop loop, Restorer restorer, TwoWayPipe pipe): + def __init__(self, EventLoop loop, Restorer restorer, FdAsyncIoStream stream): self.loop = loop self.restorer = restorer - self.network = _TwoPartyVatNetwork()._init(loop, deref(moveOwnAsyncIOStream(pipe.thisptr.ends[1])), capnp.SERVER) + self.network = _TwoPartyVatNetwork()._init(loop, deref(stream.thisptr), capnp.SERVER) self.thisptr = new RpcSystem(makeRpcServer(deref(self.network.thisptr), deref(restorer.thisptr), loop.thisptr)) def __dealloc__(self): del self.thisptr -cdef class TwoWayPipe: - cdef C_TwoWayPipe thisptr +cdef class FdAsyncIoStream: + cdef Own[AsyncIoStream] thisptr - def __init__(self): - self.thisptr = newTwoWayPipe() + def __init__(self, int fd): + self.thisptr = AsyncIoStream_wrapFd(fd) cdef class _Schema: cdef C_Schema thisptr diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index e37ea5b..c799849 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -1,7 +1,7 @@ # schema.capnp.cpp.pyx # distutils: language = c++ # distutils: extra_compile_args = --std=c++11 -from schema_cpp cimport Node, Data, StructNode, EnumNode, MessageBuilder +from schema_cpp cimport Node, Data, StructNode, EnumNode, MessageBuilder, MessageReader from async_cpp cimport PyPromise, VoidPromise, Promise from cpython.ref cimport PyObject @@ -23,6 +23,10 @@ cdef extern from "kj/string.h" namespace " ::kj": cdef cppclass String: char* cStr() +cdef extern from "kj/memory.h" namespace " ::kj": + cdef cppclass Own[T]: + T& operator*() + cdef extern from "kj/string-tree.h" namespace " ::kj": cdef cppclass StringTree: String flatten() @@ -42,14 +46,10 @@ cdef extern from "kj/array.h" namespace " ::kj": size_t size() cdef extern from "kj/async-io.h" namespace " ::kj": - cdef cppclass Own[T]: - T& operator*() - cdef cppclass AsyncIoStream: pass - cdef cppclass TwoWayPipe: - Own[AsyncIoStream] * ends - TwoWayPipe newTwoWayPipe() + + Own[AsyncIoStream] AsyncIoStream_wrapFd" ::kj::AsyncIoStream::wrapFd"(int) cdef extern from "capnp/schema.h" namespace " ::capnp": cdef cppclass Schema: @@ -224,6 +224,7 @@ cdef extern from "rpcHelper.h": cdef cppclass PyRestorer: PyRestorer(PyObject *, StructSchema&) Capability.Client restoreHelper(RpcSystem&, MessageBuilder&) + Capability.Client restoreHelper(RpcSystem&, MessageReader&) cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef cppclass DynamicEnum: diff --git a/capnp/rpcHelper.h b/capnp/rpcHelper.h index 1dc18ea..56e5aa1 100644 --- a/capnp/rpcHelper.h +++ b/capnp/rpcHelper.h @@ -40,3 +40,10 @@ capnp::Capability::Client restoreHelper(capnp::RpcSystem()); } + + +capnp::Capability::Client restoreHelper(capnp::RpcSystem& client, capnp::MessageReader & objectId) { capnp::MallocMessageBuilder hostIdMessage(8); + auto hostId = hostIdMessage.initRoot(); + hostId.setSide(capnp::rpc::twoparty::Side::SERVER); + return client.restore(hostId, objectId.getRoot()); +} diff --git a/examples/example_capability.py b/examples/example_capability.py index 6812846..ba356e8 100644 --- a/examples/example_capability.py +++ b/examples/example_capability.py @@ -1,7 +1,8 @@ from __future__ import print_function import capnp -import example_capability_capnp +import example_capability_capnp as capability +import socket class Server: def __init__(self, val=1): @@ -10,24 +11,27 @@ class Server: def foo(self, context): context.results.x = str(context.params.i * 5 + self.val) -def test_simple_rpc(): +def example_simple_rpc(): def _restore(ref_id): - return example_capability_capnp.TestInterface.new_server(Server(100)) + return capability.TestInterface.new_server(Server(100)) loop = capnp.EventLoop() - pipe = capnp.TwoWayPipe() - restorer = capnp.Restorer(example_capability_capnp.TestSturdyRefObjectId, _restore) - server = capnp.RpcServer(loop, restorer, pipe) - client = capnp.RpcClient(loop, pipe) + read, write = socket.socketpair(socket.AF_UNIX) + read_stream = capnp.FdAsyncIoStream(read.fileno()) + write_stream = capnp.FdAsyncIoStream(write.fileno()) - ref = example_capability_capnp.TestSturdyRefObjectId.new_message() + restorer = capnp.Restorer(capability.TestSturdyRefObjectId, _restore) + server = capnp.RpcServer(loop, restorer, write_stream) + client = capnp.RpcClient(loop, read_stream) + + ref = capability.TestSturdyRefObjectId.new_message() cap = client.restore(ref.as_reader()) - cap = cap.cast_as(example_capability_capnp.TestInterface) + cap = cap.cast_as(capability.TestInterface) remote = cap.foo(i=5) response = loop.wait_remote(remote) assert response.x == '125' -test_simple_rpc() \ No newline at end of file +example_simple_rpc() \ No newline at end of file diff --git a/test/test_rpc.py b/test/test_rpc.py index c920ff5..ec29984 100644 --- a/test/test_rpc.py +++ b/test/test_rpc.py @@ -1,6 +1,7 @@ import pytest import capnp import os +import socket this_dir = os.path.dirname(__file__) @@ -20,14 +21,17 @@ def test_simple_rpc(capability): return capability.TestInterface.new_server(Server(100)) loop = capnp.EventLoop() - pipe = capnp.TwoWayPipe() - + + read, write = socket.socketpair(socket.AF_UNIX) + read_stream = capnp.FdAsyncIoStream(read.fileno()) + write_stream = capnp.FdAsyncIoStream(write.fileno()) + restorer = capnp.Restorer(capability.TestSturdyRefObjectId, _restore) - server = capnp.RpcServer(loop, restorer, pipe) - client = capnp.RpcClient(loop, pipe) + server = capnp.RpcServer(loop, restorer, write_stream) + client = capnp.RpcClient(loop, read_stream) ref = capability.TestSturdyRefObjectId.new_message() - cap = client.restore(ref.as_reader()) + cap = client.restore(ref) cap = cap.cast_as(capability.TestInterface) remote = cap.foo(i=5) From 496a12667171cfe65080cacb5c87ac235b706788 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 12 Nov 2013 19:40:10 -0800 Subject: [PATCH 31/43] Add a cross language RPC example --- examples/c++.capnp | 27 + examples/example_client.py | 25 + examples/example_server.cpp | 190 + examples/test.capnp | 613 ++ examples/test.capnp.c++ | 9007 ++++++++++++++++++ examples/test.capnp.h | 16936 ++++++++++++++++++++++++++++++++++ 6 files changed, 26798 insertions(+) create mode 100644 examples/c++.capnp create mode 100644 examples/example_client.py create mode 100644 examples/example_server.cpp create mode 100644 examples/test.capnp create mode 100644 examples/test.capnp.c++ create mode 100644 examples/test.capnp.h diff --git a/examples/c++.capnp b/examples/c++.capnp new file mode 100644 index 0000000..7f306a7 --- /dev/null +++ b/examples/c++.capnp @@ -0,0 +1,27 @@ +# Copyright (c) 2013, Kenton Varda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +@0xbdf87d7bb8304e81; +$namespace("capnp::annotations"); + +annotation namespace(file): Text; diff --git a/examples/example_client.py b/examples/example_client.py new file mode 100644 index 0000000..075d6d0 --- /dev/null +++ b/examples/example_client.py @@ -0,0 +1,25 @@ +from __future__ import print_function + +import capnp +import test_capnp +import socket + +def example_client(): + loop = capnp.EventLoop() + + c = socket.create_connection(('localhost', 49999)) + read_stream = capnp.FdAsyncIoStream(c.fileno()) + + client = capnp.RpcClient(loop, read_stream) + + ref = test_capnp.TestSturdyRefObjectId.new_message() + ref.tag = 'testInterface' + cap = client.restore(ref) + cap = cap.cast_as(test_capnp.TestInterface) + + remote = cap.foo(i=5) + response = loop.wait_remote(remote) + + assert response.x == 'foo' + +example_client() \ No newline at end of file diff --git a/examples/example_server.cpp b/examples/example_server.cpp new file mode 100644 index 0000000..9b336af --- /dev/null +++ b/examples/example_server.cpp @@ -0,0 +1,190 @@ +#include +#include "capnp/rpc-twoparty.h" +#include +#include +#include "test.capnp.h" + +using namespace capnp; +using namespace capnproto_test::capnp; +using namespace kj; + +class TestInterfaceImpl final: public test::TestInterface::Server { +public: + TestInterfaceImpl(int& callCount); + + ::kj::Promise foo( + test::TestInterface::FooParams::Reader params, + test::TestInterface::FooResults::Builder result) override; + + ::kj::Promise bazAdvanced( + ::capnp::CallContext context) override; + +private: + int& callCount; +}; + +class TestExtendsImpl final: public test::TestExtends::Server { +public: + TestExtendsImpl(int& callCount); + + ::kj::Promise foo( + test::TestInterface::FooParams::Reader params, + test::TestInterface::FooResults::Builder result) override; + + ::kj::Promise graultAdvanced( + ::capnp::CallContext context) override; + +private: + int& callCount; +}; + +class TestPipelineImpl final: public test::TestPipeline::Server { +public: + TestPipelineImpl(int& callCount); + + ::kj::Promise getCapAdvanced( + capnp::CallContext context) override; + +private: + int& callCount; +}; + + +TestInterfaceImpl::TestInterfaceImpl(int& callCount): callCount(callCount) {} + +::kj::Promise TestInterfaceImpl::foo( + test::TestInterface::FooParams::Reader params, + test::TestInterface::FooResults::Builder result) { + ++callCount; + result.setX("foo"); + return kj::READY_NOW; +} + +::kj::Promise TestInterfaceImpl::bazAdvanced( + ::capnp::CallContext context) { + ++callCount; + auto params = context.getParams(); + // checkTestMessage(params.getS()); + context.releaseParams(); + + return kj::READY_NOW; +} + +TestExtendsImpl::TestExtendsImpl(int& callCount): callCount(callCount) {} + +::kj::Promise TestExtendsImpl::foo( + test::TestInterface::FooParams::Reader params, + test::TestInterface::FooResults::Builder result) { + ++callCount; + result.setX("bar"); + return kj::READY_NOW; +} + +::kj::Promise TestExtendsImpl::graultAdvanced( + ::capnp::CallContext context) { + ++callCount; + context.releaseParams(); + + // initTestMessage(context.getResults()); + + return kj::READY_NOW; +} + +TestPipelineImpl::TestPipelineImpl(int& callCount): callCount(callCount) {} + +::kj::Promise TestPipelineImpl::getCapAdvanced( + capnp::CallContext context) { + ++callCount; + + auto params = context.getParams(); + + auto cap = params.getInCap(); + context.releaseParams(); + + auto request = cap.fooRequest(); + request.setI(123); + request.setJ(true); + + return request.send().then( + [this,context](capnp::Response&& response) mutable { + + auto result = context.getResults(); + result.setS("bar"); + result.initOutBox().setCap(kj::heap(callCount)); + }); +} + + +class TestRestorer final: public SturdyRefRestorer { +public: + TestRestorer(int& callCount): callCount(callCount) {} + + Capability::Client restore(test::TestSturdyRefObjectId::Reader objectId) override { + switch (objectId.getTag()) { + case test::TestSturdyRefObjectId::Tag::TEST_INTERFACE: + return kj::heap(callCount); + // case test::TestSturdyRefObjectId::Tag::TEST_EXTENDS: + // return Capability::Client(newBrokenCap("No TestExtends implemented.")); + case test::TestSturdyRefObjectId::Tag::TEST_PIPELINE: + return kj::heap(callCount); + } + KJ_UNREACHABLE; + } + +private: + int& callCount; +}; + +void runServer(kj::Promise quit, kj::Own stream, int& callCount) { + // Set up the server. + kj::UnixEventLoop eventLoop; + TwoPartyVatNetwork network(eventLoop, *stream, rpc::twoparty::Side::SERVER); + TestRestorer restorer(callCount); + auto server = makeRpcServer(network, restorer, eventLoop); + + // Wait until quit promise is fulfilled. + eventLoop.wait(kj::mv(quit)); +} + +Capability::Client getPersistentCap(RpcSystem& client, + rpc::twoparty::Side side, + test::TestSturdyRefObjectId::Tag tag) { + // Create the SturdyRefHostId. + MallocMessageBuilder hostIdMessage(8); + auto hostId = hostIdMessage.initRoot(); + hostId.setSide(side); + + // Create the SturdyRefObjectId. + MallocMessageBuilder objectIdMessage(8); + objectIdMessage.initRoot().setTag(tag); + + // Connect to the remote capability. + return client.restore(hostId, objectIdMessage.getRoot()); +} + +using boost::asio::ip::tcp; +int main() +{ + try + { + int callCount(0); + boost::asio::io_service io_service; + + tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 49999)); + tcp::socket socket(io_service); + acceptor.accept(socket); + + kj::Own stream(AsyncIoStream::wrapFd(socket.native_handle())); + auto quitter = kj::newPromiseAndFulfiller(); + runServer(kj::mv(quitter.promise), kj::mv(stream), callCount); + } + catch (std::exception& e) + { + std::cerr << e.what() << std::endl; + } + return 0; +} \ No newline at end of file diff --git a/examples/test.capnp b/examples/test.capnp new file mode 100644 index 0000000..65406f0 --- /dev/null +++ b/examples/test.capnp @@ -0,0 +1,613 @@ +# Copyright (c) 2013, Kenton Varda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +@0xd508eebdc2dc42b8; + +using Cxx = import "c++.capnp"; + +# Use a namespace likely to cause trouble if the generated code doesn't use fully-qualified +# names for stuff in the capnproto namespace. +$Cxx.namespace("capnproto_test::capnp::test"); + +enum TestEnum { + foo @0; + bar @1; + baz @2; + qux @3; + quux @4; + corge @5; + grault @6; + garply @7; +} + +struct TestAllTypes { + voidField @0 : Void; + boolField @1 : Bool; + int8Field @2 : Int8; + int16Field @3 : Int16; + int32Field @4 : Int32; + int64Field @5 : Int64; + uInt8Field @6 : UInt8; + uInt16Field @7 : UInt16; + uInt32Field @8 : UInt32; + uInt64Field @9 : UInt64; + float32Field @10 : Float32; + float64Field @11 : Float64; + textField @12 : Text; + dataField @13 : Data; + structField @14 : TestAllTypes; + enumField @15 : TestEnum; + interfaceField @16 : Void; # TODO + + voidList @17 : List(Void); + boolList @18 : List(Bool); + int8List @19 : List(Int8); + int16List @20 : List(Int16); + int32List @21 : List(Int32); + int64List @22 : List(Int64); + uInt8List @23 : List(UInt8); + uInt16List @24 : List(UInt16); + uInt32List @25 : List(UInt32); + uInt64List @26 : List(UInt64); + float32List @27 : List(Float32); + float64List @28 : List(Float64); + textList @29 : List(Text); + dataList @30 : List(Data); + structList @31 : List(TestAllTypes); + enumList @32 : List(TestEnum); + interfaceList @33 : List(Void); # TODO +} + +struct TestDefaults { + voidField @0 : Void = void; + boolField @1 : Bool = true; + int8Field @2 : Int8 = -123; + int16Field @3 : Int16 = -12345; + int32Field @4 : Int32 = -12345678; + int64Field @5 : Int64 = -123456789012345; + uInt8Field @6 : UInt8 = 234; + uInt16Field @7 : UInt16 = 45678; + uInt32Field @8 : UInt32 = 3456789012; + uInt64Field @9 : UInt64 = 12345678901234567890; + float32Field @10 : Float32 = 1234.5; + float64Field @11 : Float64 = -123e45; + textField @12 : Text = "foo"; + dataField @13 : Data = "bar"; + structField @14 : TestAllTypes = ( + voidField = void, + boolField = true, + int8Field = -12, + int16Field = 3456, + int32Field = -78901234, + int64Field = 56789012345678, + uInt8Field = 90, + uInt16Field = 1234, + uInt32Field = 56789012, + uInt64Field = 345678901234567890, + float32Field = -1.25e-10, + float64Field = 345, + textField = "baz", + dataField = "qux", + structField = ( + textField = "nested", + structField = (textField = "really nested")), + enumField = baz, + # interfaceField can't have a default + + voidList = [void, void, void], + boolList = [false, true, false, true, true], + int8List = [12, -34, -0x80, 0x7f], + int16List = [1234, -5678, -0x8000, 0x7fff], + int32List = [12345678, -90123456, -0x80000000, 0x7fffffff], + int64List = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff], + uInt8List = [12, 34, 0, 0xff], + uInt16List = [1234, 5678, 0, 0xffff], + uInt32List = [12345678, 90123456, 0, 0xffffffff], + uInt64List = [123456789012345, 678901234567890, 0, 0xffffffffffffffff], + float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], + float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], + textList = ["quux", "corge", "grault"], + dataList = ["garply", "waldo", "fred"], + structList = [ + (textField = "x structlist 1"), + (textField = "x structlist 2"), + (textField = "x structlist 3")], + enumList = [qux, bar, grault] + # interfaceList can't have a default + ); + enumField @15 : TestEnum = corge; + interfaceField @16 : Void; # TODO + + voidList @17 : List(Void) = [void, void, void, void, void, void]; + boolList @18 : List(Bool) = [true, false, false, true]; + int8List @19 : List(Int8) = [111, -111]; + int16List @20 : List(Int16) = [11111, -11111]; + int32List @21 : List(Int32) = [111111111, -111111111]; + int64List @22 : List(Int64) = [1111111111111111111, -1111111111111111111]; + uInt8List @23 : List(UInt8) = [111, 222] ; + uInt16List @24 : List(UInt16) = [33333, 44444]; + uInt32List @25 : List(UInt32) = [3333333333]; + uInt64List @26 : List(UInt64) = [11111111111111111111]; + float32List @27 : List(Float32) = [5555.5, inf, -inf, nan]; + float64List @28 : List(Float64) = [7777.75, inf, -inf, nan]; + textList @29 : List(Text) = ["plugh", "xyzzy", "thud"]; + dataList @30 : List(Data) = ["oops", "exhausted", "rfc3092"]; + structList @31 : List(TestAllTypes) = [ + (textField = "structlist 1"), + (textField = "structlist 2"), + (textField = "structlist 3")]; + enumList @32 : List(TestEnum) = [foo, garply]; + interfaceList @33 : List(Void); # TODO +} + +struct TestObject { + objectField @0 :Object; + + # Do not add any other fields here! Some tests rely on objectField being the last pointer + # in the struct. +} + +struct TestOutOfOrder { + foo @3 :Text; + bar @2 :Text; + baz @8 :Text; + qux @0 :Text; + quux @6 :Text; + corge @4 :Text; + grault @1 :Text; + garply @7 :Text; + waldo @5 :Text; +} + +struct TestUnion { + union0 @0! :union { + # Pack union 0 under ideal conditions: there is no unused padding space prior to it. + u0f0s0 @4: Void; + u0f0s1 @5: Bool; + u0f0s8 @6: Int8; + u0f0s16 @7: Int16; + u0f0s32 @8: Int32; + u0f0s64 @9: Int64; + u0f0sp @10: Text; + + # Pack more stuff into union0 -- should go in same space. + u0f1s0 @11: Void; + u0f1s1 @12: Bool; + u0f1s8 @13: Int8; + u0f1s16 @14: Int16; + u0f1s32 @15: Int32; + u0f1s64 @16: Int64; + u0f1sp @17: Text; + } + + # Pack one bit in order to make pathological situation for union1. + bit0 @18: Bool; + + union1 @1! :union { + # Pack pathologically bad case. Each field takes up new space. + u1f0s0 @19: Void; + u1f0s1 @20: Bool; + u1f1s1 @21: Bool; + u1f0s8 @22: Int8; + u1f1s8 @23: Int8; + u1f0s16 @24: Int16; + u1f1s16 @25: Int16; + u1f0s32 @26: Int32; + u1f1s32 @27: Int32; + u1f0s64 @28: Int64; + u1f1s64 @29: Int64; + u1f0sp @30: Text; + u1f1sp @31: Text; + + # Pack more stuff into union1 -- each should go into the same space as corresponding u1f0s*. + u1f2s0 @32: Void; + u1f2s1 @33: Bool; + u1f2s8 @34: Int8; + u1f2s16 @35: Int16; + u1f2s32 @36: Int32; + u1f2s64 @37: Int64; + u1f2sp @38: Text; + } + + # Fill in the rest of that bitfield from earlier. + bit2 @39: Bool; + bit3 @40: Bool; + bit4 @41: Bool; + bit5 @42: Bool; + bit6 @43: Bool; + bit7 @44: Bool; + + # Interleave two unions to be really annoying. + # Also declare in reverse order to make sure union discriminant values are sorted by field number + # and not by declaration order. + union2 @2! :union { + u2f0s64 @54: Int64; + u2f0s32 @52: Int32; + u2f0s16 @50: Int16; + u2f0s8 @47: Int8; + u2f0s1 @45: Bool; + } + + union3 @3! :union { + u3f0s64 @55: Int64; + u3f0s32 @53: Int32; + u3f0s16 @51: Int16; + u3f0s8 @48: Int8; + u3f0s1 @46: Bool; + } + + byte0 @49: UInt8; +} + +struct TestUnnamedUnion { + before @0 :Text; + + union { + foo @1 :UInt16; + bar @3 :UInt32; + } + + middle @2 :UInt16; + + after @4 :Text; +} + +struct TestUnionInUnion { + # There is no reason to ever do this. + outer :union { + inner :union { + foo @0 :Int32; + bar @1 :Int32; + } + baz @2 :Int32; + } +} + +struct TestGroups { + groups :union { + foo :group { + corge @0 :Int32; + grault @2 :Int64; + garply @8 :Text; + } + bar :group { + corge @3 :Int32; + grault @4 :Text; + garply @5 :Int64; + } + baz :group { + corge @1 :Int32; + grault @6 :Text; + garply @7 :Text; + } + } +} + +struct TestInterleavedGroups { + group1 :group { + foo @0 :UInt32; + bar @2 :UInt64; + union { + qux @4 :UInt16; + corge :group { + grault @6 :UInt64; + garply @8 :UInt16; + plugh @14 :Text; + xyzzy @16 :Text; + } + + fred @12 :Text; + } + + waldo @10 :Text; + } + + group2 :group { + foo @1 :UInt32; + bar @3 :UInt64; + union { + qux @5 :UInt16; + corge :group { + grault @7 :UInt64; + garply @9 :UInt16; + plugh @15 :Text; + xyzzy @17 :Text; + } + + fred @13 :Text; + } + + waldo @11 :Text; + } +} + +struct TestUnionDefaults { + s16s8s64s8Set @0 :TestUnion = + (union0 = (u0f0s16 = 321), union1 = (u1f0s8 = 123), union2 = (u2f0s64 = 12345678901234567), + union3 = (u3f0s8 = 55)); + s0sps1s32Set @1 :TestUnion = + (union0 = (u0f1s0 = void), union1 = (u1f0sp = "foo"), union2 = (u2f0s1 = true), + union3 = (u3f0s32 = 12345678)); + + unnamed1 @2 :TestUnnamedUnion = (foo = 123); + unnamed2 @3 :TestUnnamedUnion = (bar = 321, before = "foo", after = "bar"); +} + +struct TestNestedTypes { + enum NestedEnum { + foo @0; + bar @1; + } + + struct NestedStruct { + enum NestedEnum { + baz @0; + qux @1; + quux @2; + } + + outerNestedEnum @0 :TestNestedTypes.NestedEnum = bar; + innerNestedEnum @1 :NestedEnum = quux; + } + + nestedStruct @0 :NestedStruct; + + outerNestedEnum @1 :NestedEnum = bar; + innerNestedEnum @2 :NestedStruct.NestedEnum = quux; +} + +struct TestUsing { + using OuterNestedEnum = TestNestedTypes.NestedEnum; + using TestNestedTypes.NestedStruct.NestedEnum; + + outerNestedEnum @1 :OuterNestedEnum = bar; + innerNestedEnum @0 :NestedEnum = quux; +} + +struct TestLists { + # Small structs, when encoded as list, will be encoded as primitive lists rather than struct + # lists, to save space. + struct Struct0 { f @0 :Void; } + struct Struct1 { f @0 :Bool; } + struct Struct8 { f @0 :UInt8; } + struct Struct16 { f @0 :UInt16; } + struct Struct32 { f @0 :UInt32; } + struct Struct64 { f @0 :UInt64; } + struct StructP { f @0 :Text; } + + # Versions of the above which cannot be encoded as primitive lists. + struct Struct0c { f @0 :Void; pad @1 :Text; } + struct Struct1c { f @0 :Bool; pad @1 :Text; } + struct Struct8c { f @0 :UInt8; pad @1 :Text; } + struct Struct16c { f @0 :UInt16; pad @1 :Text; } + struct Struct32c { f @0 :UInt32; pad @1 :Text; } + struct Struct64c { f @0 :UInt64; pad @1 :Text; } + struct StructPc { f @0 :Text; pad @1 :UInt64; } + + list0 @0 :List(Struct0); + list1 @1 :List(Struct1); + list8 @2 :List(Struct8); + list16 @3 :List(Struct16); + list32 @4 :List(Struct32); + list64 @5 :List(Struct64); + listP @6 :List(StructP); + + int32ListList @7 :List(List(Int32)); + textListList @8 :List(List(Text)); + structListList @9 :List(List(TestAllTypes)); +} + +struct TestFieldZeroIsBit { + bit @0 :Bool; + secondBit @1 :Bool = true; + thirdField @2 :UInt8 = 123; +} + +struct TestListDefaults { + lists @0 :TestLists = ( + list0 = [(f = void), (f = void)], + list1 = [(f = true), (f = false), (f = true), (f = true)], + list8 = [(f = 123), (f = 45)], + list16 = [(f = 12345), (f = 6789)], + list32 = [(f = 123456789), (f = 234567890)], + list64 = [(f = 1234567890123456), (f = 2345678901234567)], + listP = [(f = "foo"), (f = "bar")], + int32ListList = [[1, 2, 3], [4, 5], [12341234]], + textListList = [["foo", "bar"], ["baz"], ["qux", "corge"]], + structListList = [[(int32Field = 123), (int32Field = 456)], [(int32Field = 789)]]); +} + +struct TestLateUnion { + # Test what happens if the unions are not the first ordinals in the struct. At one point this + # was broken for the dynamic API. + + foo @0 :Int32; + bar @1 :Text; + baz @2 :Int16; + + theUnion @3! :union { + qux @4 :Text; + corge @5 :List(Int32); + grault @6 :Float32; + } + + anotherUnion @7! :union { + qux @8 :Text; + corge @9 :List(Int32); + grault @10 :Float32; + } +} + +struct TestOldVersion { + # A subset of TestNewVersion. + old1 @0 :Int64; + old2 @1 :Text; + old3 @2 :TestOldVersion; +} + +struct TestNewVersion { + # A superset of TestOldVersion. + old1 @0 :Int64; + old2 @1 :Text; + old3 @2 :TestNewVersion; + new1 @3 :Int64 = 987; + new2 @4 :Text = "baz"; +} + +struct TestStructUnion { + un @0! :union { + allTypes @1 :TestAllTypes; + object @2 :TestObject; + } +} + +struct TestEmptyStruct {} + +struct TestConstants { + const voidConst :Void = void; + const boolConst :Bool = true; + const int8Const :Int8 = -123; + const int16Const :Int16 = -12345; + const int32Const :Int32 = -12345678; + const int64Const :Int64 = -123456789012345; + const uint8Const :UInt8 = 234; + const uint16Const :UInt16 = 45678; + const uint32Const :UInt32 = 3456789012; + const uint64Const :UInt64 = 12345678901234567890; + const float32Const :Float32 = 1234.5; + const float64Const :Float64 = -123e45; + const textConst :Text = "foo"; + const dataConst :Data = "bar"; + const structConst :TestAllTypes = ( + voidField = void, + boolField = true, + int8Field = -12, + int16Field = 3456, + int32Field = -78901234, + int64Field = 56789012345678, + uInt8Field = 90, + uInt16Field = 1234, + uInt32Field = 56789012, + uInt64Field = 345678901234567890, + float32Field = -1.25e-10, + float64Field = 345, + textField = "baz", + dataField = "qux", + structField = ( + textField = "nested", + structField = (textField = "really nested")), + enumField = baz, + # interfaceField can't have a default + + voidList = [void, void, void], + boolList = [false, true, false, true, true], + int8List = [12, -34, -0x80, 0x7f], + int16List = [1234, -5678, -0x8000, 0x7fff], + int32List = [12345678, -90123456, -0x80000000, 0x7fffffff], + int64List = [123456789012345, -678901234567890, -0x8000000000000000, 0x7fffffffffffffff], + uInt8List = [12, 34, 0, 0xff], + uInt16List = [1234, 5678, 0, 0xffff], + uInt32List = [12345678, 90123456, 0, 0xffffffff], + uInt64List = [123456789012345, 678901234567890, 0, 0xffffffffffffffff], + float32List = [0, 1234567, 1e37, -1e37, 1e-37, -1e-37], + float64List = [0, 123456789012345, 1e306, -1e306, 1e-306, -1e-306], + textList = ["quux", "corge", "grault"], + dataList = ["garply", "waldo", "fred"], + structList = [ + (textField = "x structlist 1"), + (textField = "x structlist 2"), + (textField = "x structlist 3")], + enumList = [qux, bar, grault] + # interfaceList can't have a default + ); + const enumConst :TestEnum = corge; + + const voidListConst :List(Void) = [void, void, void, void, void, void]; + const boolListConst :List(Bool) = [true, false, false, true]; + const int8ListConst :List(Int8) = [111, -111]; + const int16ListConst :List(Int16) = [11111, -11111]; + const int32ListConst :List(Int32) = [111111111, -111111111]; + const int64ListConst :List(Int64) = [1111111111111111111, -1111111111111111111]; + const uint8ListConst :List(UInt8) = [111, 222] ; + const uint16ListConst :List(UInt16) = [33333, 44444]; + const uint32ListConst :List(UInt32) = [3333333333]; + const uint64ListConst :List(UInt64) = [11111111111111111111]; + const float32ListConst :List(Float32) = [5555.5, inf, -inf, nan]; + const float64ListConst :List(Float64) = [7777.75, inf, -inf, nan]; + const textListConst :List(Text) = ["plugh", "xyzzy", "thud"]; + const dataListConst :List(Data) = ["oops", "exhausted", "rfc3092"]; + const structListConst :List(TestAllTypes) = [ + (textField = "structlist 1"), + (textField = "structlist 2"), + (textField = "structlist 3")]; + const enumListConst :List(TestEnum) = [foo, garply]; +} + +const globalInt :UInt32 = 12345; +const globalText :Text = "foobar"; +const globalStruct :TestAllTypes = (int32Field = 54321); +const derivedConstant :TestAllTypes = ( + uInt32Field = .globalInt, + textField = TestConstants.textConst, + structField = TestConstants.structConst, + int16List = TestConstants.int16ListConst, + structList = TestConstants.structListConst); + +interface TestInterface { + foo @0 (i :UInt32, j :Bool) -> (x: Text); + bar @1 () -> (); + baz @2 (s: TestAllTypes); +} + +interface TestExtends extends(TestInterface) { + qux @0 (); + corge @1 TestAllTypes -> (); + grault @2 () -> TestAllTypes; +} + +interface TestPipeline { + getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); + testPointers @1 (cap :TestInterface, obj :Object, list :List(TestInterface)) -> (); + + struct Box { + cap @0 :TestInterface; + } +} + +struct TestSturdyRefHostId { + host @0 :Text; +} + +struct TestSturdyRefObjectId { + tag @0 :Tag; + enum Tag { + testInterface @0; + testExtends @1; + testPipeline @2; + } +} + +struct TestProvisionId {} +struct TestRecipientId {} +struct TestThirdPartyCapId {} +struct TestJoinAnswer {} diff --git a/examples/test.capnp.c++ b/examples/test.capnp.c++ new file mode 100644 index 0000000..22620e1 --- /dev/null +++ b/examples/test.capnp.c++ @@ -0,0 +1,9007 @@ +// Generated by Cap'n Proto compiler, DO NOT EDIT +// source: test.capnp + +#include "test.capnp.h" + +namespace capnp { +namespace schemas { +static const ::capnp::_::AlignedData<49> b_9c8e9318b29d9cd3 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 2, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 210, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 199, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 69, 110, 117, + 109, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 32, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 89, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 65, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 57, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, } +}; +static const uint16_t m_9c8e9318b29d9cd3[] = {1, 2, 5, 0, 7, 6, 4, 3}; +const ::capnp::_::RawSchema s_9c8e9318b29d9cd3 = { + 0x9c8e9318b29d9cd3, b_9c8e9318b29d9cd3.words, 49, nullptr, m_9c8e9318b29d9cd3, + 0, 8, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<578> b_a0a8f314b80b63fd = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 1, 0, 6, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 20, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 242, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 65, 108, 108, + 84, 121, 112, 101, 115, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 136, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 169, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 3, 0, 0, 2, 0, 1, 0, + 176, 3, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 173, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 172, 3, 0, 0, 2, 0, 1, 0, + 180, 3, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 177, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 3, 0, 0, 2, 0, 1, 0, + 184, 3, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 181, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 180, 3, 0, 0, 2, 0, 1, 0, + 188, 3, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 185, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 184, 3, 0, 0, 2, 0, 1, 0, + 192, 3, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 188, 3, 0, 0, 2, 0, 1, 0, + 196, 3, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 193, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 3, 0, 0, 2, 0, 1, 0, + 200, 3, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 197, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 196, 3, 0, 0, 2, 0, 1, 0, + 204, 3, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 201, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 200, 3, 0, 0, 2, 0, 1, 0, + 208, 3, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 205, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 204, 3, 0, 0, 2, 0, 1, 0, + 212, 3, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 3, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 3, 0, 0, 2, 0, 1, 0, + 216, 3, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 213, 3, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 212, 3, 0, 0, 2, 0, 1, 0, + 220, 3, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 217, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 216, 3, 0, 0, 2, 0, 1, 0, + 224, 3, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 221, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 3, 0, 0, 2, 0, 1, 0, + 228, 3, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 224, 3, 0, 0, 2, 0, 1, 0, + 232, 3, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 229, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 228, 3, 0, 0, 2, 0, 1, 0, + 236, 3, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 3, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 3, 0, 0, 2, 0, 1, 0, + 240, 3, 0, 0, 2, 0, 1, 0, + 17, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 3, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 3, 0, 0, 2, 0, 1, 0, + 0, 4, 0, 0, 2, 0, 1, 0, + 18, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 253, 3, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 252, 3, 0, 0, 2, 0, 1, 0, + 16, 4, 0, 0, 2, 0, 1, 0, + 19, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 4, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 4, 0, 0, 2, 0, 1, 0, + 32, 4, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 20, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 4, 0, 0, 2, 0, 1, 0, + 48, 4, 0, 0, 2, 0, 1, 0, + 21, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 21, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 4, 0, 0, 2, 0, 1, 0, + 64, 4, 0, 0, 2, 0, 1, 0, + 22, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 22, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 61, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 60, 4, 0, 0, 2, 0, 1, 0, + 80, 4, 0, 0, 2, 0, 1, 0, + 23, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 4, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 4, 0, 0, 2, 0, 1, 0, + 96, 4, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 1, 0, 24, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 4, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 4, 0, 0, 2, 0, 1, 0, + 112, 4, 0, 0, 2, 0, 1, 0, + 25, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 1, 0, 25, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 4, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 4, 0, 0, 2, 0, 1, 0, + 128, 4, 0, 0, 2, 0, 1, 0, + 26, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 4, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 4, 0, 0, 2, 0, 1, 0, + 144, 4, 0, 0, 2, 0, 1, 0, + 27, 0, 0, 0, 13, 0, 0, 0, + 0, 0, 1, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 4, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 4, 0, 0, 2, 0, 1, 0, + 160, 4, 0, 0, 2, 0, 1, 0, + 28, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 1, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 157, 4, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 156, 4, 0, 0, 2, 0, 1, 0, + 176, 4, 0, 0, 2, 0, 1, 0, + 29, 0, 0, 0, 15, 0, 0, 0, + 0, 0, 1, 0, 29, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 173, 4, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 172, 4, 0, 0, 2, 0, 1, 0, + 192, 4, 0, 0, 2, 0, 1, 0, + 30, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 30, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 4, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 188, 4, 0, 0, 2, 0, 1, 0, + 208, 4, 0, 0, 2, 0, 1, 0, + 31, 0, 0, 0, 17, 0, 0, 0, + 0, 0, 1, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 205, 4, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 204, 4, 0, 0, 2, 0, 1, 0, + 224, 4, 0, 0, 2, 0, 1, 0, + 32, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 221, 4, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 4, 0, 0, 2, 0, 1, 0, + 240, 4, 0, 0, 2, 0, 1, 0, + 33, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 1, 0, 33, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 4, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 236, 4, 0, 0, 2, 0, 1, 0, + 0, 5, 0, 0, 2, 0, 1, 0, + 118, 111, 105, 100, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 111, 108, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 54, 52, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 56, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 49, 54, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 51, 50, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 51, 50, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 97, 116, 97, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 110, 117, 109, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 70, 105, 101, 108, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 118, 111, 105, 100, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 111, 108, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 54, 52, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 56, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 49, 54, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 51, 50, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 51, 50, 76, + 105, 115, 116, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 76, + 105, 115, 116, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 100, 97, 116, 97, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 101, 110, 117, 109, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 76, 105, 115, 116, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_a0a8f314b80b63fd[] = { + &s_9c8e9318b29d9cd3, + &s_a0a8f314b80b63fd, +}; +static const uint16_t m_a0a8f314b80b63fd[] = {1, 18, 13, 30, 15, 32, 10, 27, 11, 28, 3, 20, 4, 21, 5, 22, 2, 19, 16, 33, 14, 31, 12, 29, 7, 24, 8, 25, 9, 26, 6, 23, 0, 17}; +static const uint16_t i_a0a8f314b80b63fd[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33}; +const ::capnp::_::RawSchema s_a0a8f314b80b63fd = { + 0xa0a8f314b80b63fd, b_a0a8f314b80b63fd.words, 578, d_a0a8f314b80b63fd, m_a0a8f314b80b63fd, + 2, 34, i_a0a8f314b80b63fd, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<902> b_eb3f9ebe98c73cb6 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 182, 60, 199, 152, 190, 158, 63, 235, + 0, 0, 0, 0, 1, 0, 6, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 20, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 242, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 7, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 68, 101, 102, + 97, 117, 108, 116, 115, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 136, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 169, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 3, 0, 0, 2, 0, 1, 0, + 176, 3, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 173, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 172, 3, 0, 0, 2, 0, 1, 0, + 180, 3, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 177, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 176, 3, 0, 0, 2, 0, 1, 0, + 184, 3, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 181, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 180, 3, 0, 0, 2, 0, 1, 0, + 188, 3, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 185, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 184, 3, 0, 0, 2, 0, 1, 0, + 192, 3, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 188, 3, 0, 0, 2, 0, 1, 0, + 196, 3, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 193, 3, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 192, 3, 0, 0, 2, 0, 1, 0, + 200, 3, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 197, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 196, 3, 0, 0, 2, 0, 1, 0, + 204, 3, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 201, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 200, 3, 0, 0, 2, 0, 1, 0, + 208, 3, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 205, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 204, 3, 0, 0, 2, 0, 1, 0, + 212, 3, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 3, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 3, 0, 0, 2, 0, 1, 0, + 216, 3, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 213, 3, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 212, 3, 0, 0, 2, 0, 1, 0, + 220, 3, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 217, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 216, 3, 0, 0, 2, 0, 1, 0, + 224, 3, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 3, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 224, 3, 0, 0, 2, 0, 1, 0, + 232, 3, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 3, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 3, 0, 0, 2, 0, 1, 0, + 240, 3, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 7, 0, 0, 2, 0, 1, 0, + 48, 7, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 7, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 7, 0, 0, 2, 0, 1, 0, + 52, 7, 0, 0, 2, 0, 1, 0, + 17, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 7, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 7, 0, 0, 2, 0, 1, 0, + 68, 7, 0, 0, 2, 0, 1, 0, + 18, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 65, 7, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 7, 0, 0, 2, 0, 1, 0, + 84, 7, 0, 0, 2, 0, 1, 0, + 19, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 85, 7, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 84, 7, 0, 0, 2, 0, 1, 0, + 104, 7, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 20, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 104, 7, 0, 0, 2, 0, 1, 0, + 124, 7, 0, 0, 2, 0, 1, 0, + 21, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 21, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 7, 0, 0, 2, 0, 1, 0, + 144, 7, 0, 0, 2, 0, 1, 0, + 22, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 22, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 144, 7, 0, 0, 2, 0, 1, 0, + 164, 7, 0, 0, 2, 0, 1, 0, + 23, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 169, 7, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 168, 7, 0, 0, 2, 0, 1, 0, + 188, 7, 0, 0, 2, 0, 1, 0, + 24, 0, 0, 0, 10, 0, 0, 0, + 0, 0, 1, 0, 24, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 7, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 188, 7, 0, 0, 2, 0, 1, 0, + 208, 7, 0, 0, 2, 0, 1, 0, + 25, 0, 0, 0, 11, 0, 0, 0, + 0, 0, 1, 0, 25, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 7, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 7, 0, 0, 2, 0, 1, 0, + 228, 7, 0, 0, 2, 0, 1, 0, + 26, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 229, 7, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 228, 7, 0, 0, 2, 0, 1, 0, + 248, 7, 0, 0, 2, 0, 1, 0, + 27, 0, 0, 0, 13, 0, 0, 0, + 0, 0, 1, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 249, 7, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 248, 7, 0, 0, 2, 0, 1, 0, + 12, 8, 0, 0, 2, 0, 1, 0, + 28, 0, 0, 0, 14, 0, 0, 0, + 0, 0, 1, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 8, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 8, 0, 0, 2, 0, 1, 0, + 36, 8, 0, 0, 2, 0, 1, 0, + 29, 0, 0, 0, 15, 0, 0, 0, + 0, 0, 1, 0, 29, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 8, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 48, 8, 0, 0, 2, 0, 1, 0, + 68, 8, 0, 0, 2, 0, 1, 0, + 30, 0, 0, 0, 16, 0, 0, 0, + 0, 0, 1, 0, 30, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 89, 8, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 88, 8, 0, 0, 2, 0, 1, 0, + 108, 8, 0, 0, 2, 0, 1, 0, + 31, 0, 0, 0, 17, 0, 0, 0, + 0, 0, 1, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 133, 8, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 132, 8, 0, 0, 2, 0, 1, 0, + 152, 8, 0, 0, 2, 0, 1, 0, + 32, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 1, 0, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 9, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 9, 0, 0, 2, 0, 1, 0, + 252, 9, 0, 0, 2, 0, 1, 0, + 33, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 1, 0, 33, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 253, 9, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 252, 9, 0, 0, 2, 0, 1, 0, + 16, 10, 0, 0, 2, 0, 1, 0, + 118, 111, 105, 100, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 111, 108, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 133, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 199, 207, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 178, 158, 67, 255, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 54, 52, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 135, 32, 242, 121, 183, 143, 255, 255, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 56, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 234, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 49, 54, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 110, 178, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 51, 50, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 20, 106, 10, 206, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 210, 10, 31, 235, 140, 169, 84, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 51, 50, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 80, 154, 68, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 70, + 105, 101, 108, 100, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 187, 224, 192, 130, 139, 181, 201, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 100, 97, 116, 97, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, + 101, 110, 117, 109, 70, 105, 101, 108, + 100, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 70, 105, 101, 108, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 118, 111, 105, 100, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 48, 0, 0, 0, + 98, 111, 111, 108, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 33, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 111, 145, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 103, 43, 153, 212, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 20, 0, 0, 0, + 199, 107, 159, 6, 57, 148, 96, 249, + 105, 110, 116, 54, 52, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 21, 0, 0, 0, + 199, 113, 196, 43, 171, 117, 107, 15, + 57, 142, 59, 212, 84, 138, 148, 240, + 117, 73, 110, 116, 56, 76, 105, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 111, 222, 0, 0, 0, 0, 0, 0, + 117, 73, 110, 116, 49, 54, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 53, 130, 156, 173, 0, 0, 0, 0, + 117, 73, 110, 116, 51, 50, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 12, 0, 0, 0, + 85, 161, 174, 198, 0, 0, 0, 0, + 117, 73, 110, 116, 54, 52, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 13, 0, 0, 0, + 199, 113, 172, 181, 175, 152, 50, 154, + 102, 108, 111, 97, 116, 51, 50, 76, + 105, 115, 116, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 36, 0, 0, 0, + 0, 156, 173, 69, 0, 0, 128, 127, + 0, 0, 128, 255, 0, 0, 192, 127, + 102, 108, 111, 97, 116, 54, 52, 76, + 105, 115, 116, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 37, 0, 0, 0, + 0, 0, 0, 0, 192, 97, 190, 64, + 0, 0, 0, 0, 0, 0, 240, 127, + 0, 0, 0, 0, 0, 0, 240, 255, + 0, 0, 0, 0, 0, 0, 248, 127, + 116, 101, 120, 116, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 30, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 116, 104, 117, 100, 0, 0, 0, 0, + 100, 97, 116, 97, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 30, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 9, 0, 0, 0, 74, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 111, 111, 112, 115, 0, 0, 0, 0, + 101, 120, 104, 97, 117, 115, 116, 101, + 100, 0, 0, 0, 0, 0, 0, 0, + 114, 102, 99, 51, 48, 57, 50, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 119, 2, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 49, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 50, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 51, 0, 0, 0, 0, + 101, 110, 117, 109, 76, 105, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, + 105, 110, 116, 101, 114, 102, 97, 99, + 101, 76, 105, 115, 116, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_eb3f9ebe98c73cb6[] = { + &s_9c8e9318b29d9cd3, + &s_a0a8f314b80b63fd, +}; +static const uint16_t m_eb3f9ebe98c73cb6[] = {1, 18, 13, 30, 15, 32, 10, 27, 11, 28, 3, 20, 4, 21, 5, 22, 2, 19, 16, 33, 14, 31, 12, 29, 7, 24, 8, 25, 9, 26, 6, 23, 0, 17}; +static const uint16_t i_eb3f9ebe98c73cb6[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33}; +const ::capnp::_::RawSchema s_eb3f9ebe98c73cb6 = { + 0xeb3f9ebe98c73cb6, b_eb3f9ebe98c73cb6.words, 902, d_eb3f9ebe98c73cb6, m_eb3f9ebe98c73cb6, + 2, 34, i_eb3f9ebe98c73cb6, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_d1f4434616a112ca = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 202, 18, 161, 22, 70, 67, 244, 209, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 226, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 79, 98, 106, + 101, 99, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 111, 98, 106, 101, 99, 116, 70, 105, + 101, 108, 100, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_d1f4434616a112ca[] = {0}; +static const uint16_t i_d1f4434616a112ca[] = {0}; +const ::capnp::_::RawSchema s_d1f4434616a112ca = { + 0xd1f4434616a112ca, b_d1f4434616a112ca.words, 32, nullptr, m_d1f4434616a112ca, + 0, 1, i_d1f4434616a112ca, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<143> b_a9d5f8efe770022b = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 43, 2, 112, 231, 239, 248, 213, 169, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 9, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 2, 1, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 255, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 79, 117, 116, + 79, 102, 79, 114, 100, 101, 114, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 36, 0, 0, 0, 3, 0, 4, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 237, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 232, 0, 0, 0, 2, 0, 1, 0, + 240, 0, 0, 0, 2, 0, 1, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_a9d5f8efe770022b[] = {2, 8, 4, 3, 7, 1, 6, 0, 5}; +static const uint16_t i_a9d5f8efe770022b[] = {0, 1, 2, 3, 4, 5, 6, 7, 8}; +const ::capnp::_::RawSchema s_a9d5f8efe770022b = { + 0xa9d5f8efe770022b, b_a9d5f8efe770022b.words, 143, nullptr, m_a9d5f8efe770022b, + 0, 9, i_a9d5f8efe770022b, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<161> b_f47697362233ce52 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 0, 0, 0, 0, 1, 0, 8, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 218, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 167, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 48, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 24, 167, 183, 236, 46, 168, 118, 252, + 65, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 1, 0, 0, 0, + 178, 122, 220, 183, 153, 107, 10, 238, + 41, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 2, 0, 0, 0, + 212, 102, 13, 159, 65, 253, 197, 175, + 17, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 3, 0, 0, 0, + 83, 0, 243, 199, 46, 2, 251, 162, + 249, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 128, 0, 0, 0, + 0, 0, 1, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 1, 0, 39, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 131, 0, 0, 0, + 0, 0, 1, 0, 40, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 132, 0, 0, 0, + 0, 0, 1, 0, 41, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 133, 0, 0, 0, + 0, 0, 1, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 134, 0, 0, 0, + 0, 0, 1, 0, 43, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 135, 0, 0, 0, + 0, 0, 1, 0, 44, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 35, 0, 0, 0, + 0, 0, 1, 0, 49, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 225, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 220, 0, 0, 0, 2, 0, 1, 0, + 228, 0, 0, 0, 2, 0, 1, 0, + 117, 110, 105, 111, 110, 48, 0, 0, + 117, 110, 105, 111, 110, 49, 0, 0, + 117, 110, 105, 111, 110, 50, 0, 0, + 117, 110, 105, 111, 110, 51, 0, 0, + 98, 105, 116, 48, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 50, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 51, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 52, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 53, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 54, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 105, 116, 55, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 121, 116, 101, 48, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_f47697362233ce52[] = { + &s_a2fb022ec7f30053, + &s_afc5fd419f0d66d4, + &s_ee0a6b99b7dc7ab2, + &s_fc76a82eecb7a718, +}; +static const uint16_t m_f47697362233ce52[] = {4, 5, 6, 7, 8, 9, 10, 11, 0, 1, 2, 3}; +static const uint16_t i_f47697362233ce52[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; +const ::capnp::_::RawSchema s_f47697362233ce52 = { + 0xf47697362233ce52, b_f47697362233ce52.words, 161, d_f47697362233ce52, m_f47697362233ce52, + 4, 12, i_f47697362233ce52, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<213> b_fc76a82eecb7a718 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 24, 167, 183, 236, 46, 168, 118, 252, + 27, 0, 0, 0, 1, 0, 8, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 2, 0, 7, 0, 1, 0, 14, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 23, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 46, 117, 110, 105, 111, 110, + 48, 0, 0, 0, 0, 0, 0, 0, + 56, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 64, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 8, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 3, 0, 252, 255, 4, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 251, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 250, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 249, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 7, 0, 248, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 8, 0, 247, 255, 64, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 9, 0, 246, 255, 8, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 10, 0, 245, 255, 4, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 11, 0, 244, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 12, 0, 243, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 13, 0, 242, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 117, 48, 102, 48, 115, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 48, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 48, 102, 49, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_fc76a82eecb7a718[] = { + &s_f47697362233ce52, +}; +static const uint16_t m_fc76a82eecb7a718[] = {0, 1, 3, 4, 5, 2, 6, 7, 8, 10, 11, 12, 9, 13}; +static const uint16_t i_fc76a82eecb7a718[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; +const ::capnp::_::RawSchema s_fc76a82eecb7a718 = { + 0xfc76a82eecb7a718, b_fc76a82eecb7a718.words, 213, d_fc76a82eecb7a718, m_fc76a82eecb7a718, + 1, 14, i_fc76a82eecb7a718, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<297> b_ee0a6b99b7dc7ab2 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 178, 122, 220, 183, 153, 107, 10, 238, + 27, 0, 0, 0, 1, 0, 8, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 2, 0, 7, 0, 1, 0, 20, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 103, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 46, 117, 110, 105, 111, 110, + 49, 0, 0, 0, 0, 0, 0, 0, + 80, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 129, 0, 0, 0, + 0, 0, 1, 0, 20, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 129, 0, 0, 0, + 0, 0, 1, 0, 21, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 3, 0, 252, 255, 17, 0, 0, 0, + 0, 0, 1, 0, 22, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 4, 0, 251, 255, 17, 0, 0, 0, + 0, 0, 1, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 5, 0, 250, 255, 9, 0, 0, 0, + 0, 0, 1, 0, 24, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 6, 0, 249, 255, 9, 0, 0, 0, + 0, 0, 1, 0, 25, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 7, 0, 248, 255, 5, 0, 0, 0, + 0, 0, 1, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 8, 0, 247, 255, 5, 0, 0, 0, + 0, 0, 1, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 9, 0, 246, 255, 3, 0, 0, 0, + 0, 0, 1, 0, 28, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 10, 0, 245, 255, 3, 0, 0, 0, + 0, 0, 1, 0, 29, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 11, 0, 244, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 30, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 12, 0, 243, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 31, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 13, 0, 242, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 32, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 14, 0, 241, 255, 129, 0, 0, 0, + 0, 0, 1, 0, 33, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 15, 0, 240, 255, 17, 0, 0, 0, + 0, 0, 1, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 16, 0, 239, 255, 9, 0, 0, 0, + 0, 0, 1, 0, 35, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 17, 0, 238, 255, 5, 0, 0, 0, + 0, 0, 1, 0, 36, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 18, 0, 237, 255, 3, 0, 0, 0, + 0, 0, 1, 0, 37, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 19, 0, 236, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 38, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 2, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 2, 0, 0, 2, 0, 1, 0, + 36, 2, 0, 0, 2, 0, 1, 0, + 117, 49, 102, 48, 115, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 48, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 49, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 49, 102, 50, 115, 112, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_ee0a6b99b7dc7ab2[] = { + &s_f47697362233ce52, +}; +static const uint16_t m_ee0a6b99b7dc7ab2[] = {0, 1, 5, 7, 9, 3, 11, 2, 6, 8, 10, 4, 12, 13, 14, 16, 17, 18, 15, 19}; +static const uint16_t i_ee0a6b99b7dc7ab2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}; +const ::capnp::_::RawSchema s_ee0a6b99b7dc7ab2 = { + 0xee0a6b99b7dc7ab2, b_ee0a6b99b7dc7ab2.words, 297, d_ee0a6b99b7dc7ab2, m_ee0a6b99b7dc7ab2, + 1, 20, i_ee0a6b99b7dc7ab2, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<87> b_afc5fd419f0d66d4 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 212, 102, 13, 159, 65, 253, 197, 175, + 27, 0, 0, 0, 1, 0, 8, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 2, 0, 7, 0, 1, 0, 5, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 46, 117, 110, 105, 111, 110, + 50, 0, 0, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 4, 0, 255, 255, 0, 1, 0, 0, + 0, 0, 1, 0, 45, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 33, 0, 0, 0, + 0, 0, 1, 0, 47, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 18, 0, 0, 0, + 0, 0, 1, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 252, 255, 10, 0, 0, 0, + 0, 0, 1, 0, 52, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 251, 255, 6, 0, 0, 0, + 0, 0, 1, 0, 54, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 117, 50, 102, 48, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 50, 102, 48, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 50, 102, 48, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 50, 102, 48, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 50, 102, 48, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_afc5fd419f0d66d4[] = { + &s_f47697362233ce52, +}; +static const uint16_t m_afc5fd419f0d66d4[] = {0, 2, 3, 4, 1}; +static const uint16_t i_afc5fd419f0d66d4[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_afc5fd419f0d66d4 = { + 0xafc5fd419f0d66d4, b_afc5fd419f0d66d4.words, 87, d_afc5fd419f0d66d4, m_afc5fd419f0d66d4, + 1, 5, i_afc5fd419f0d66d4, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<87> b_a2fb022ec7f30053 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 83, 0, 243, 199, 46, 2, 251, 162, + 27, 0, 0, 0, 1, 0, 8, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 2, 0, 7, 0, 1, 0, 5, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 46, 117, 110, 105, 111, 110, + 51, 0, 0, 0, 0, 0, 0, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 4, 0, 255, 255, 1, 1, 0, 0, + 0, 0, 1, 0, 46, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 34, 0, 0, 0, + 0, 0, 1, 0, 48, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 19, 0, 0, 0, + 0, 0, 1, 0, 51, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 252, 255, 11, 0, 0, 0, + 0, 0, 1, 0, 53, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 251, 255, 7, 0, 0, 0, + 0, 0, 1, 0, 55, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 66, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 117, 51, 102, 48, 115, 49, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 51, 102, 48, 115, 56, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 51, 102, 48, 115, 49, 54, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 51, 102, 48, 115, 51, 50, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 51, 102, 48, 115, 54, 52, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_a2fb022ec7f30053[] = { + &s_f47697362233ce52, +}; +static const uint16_t m_a2fb022ec7f30053[] = {0, 2, 3, 4, 1}; +static const uint16_t i_a2fb022ec7f30053[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_a2fb022ec7f30053 = { + 0xa2fb022ec7f30053, b_a2fb022ec7f30053.words, 87, d_a2fb022ec7f30053, m_a2fb022ec7f30053, + 1, 5, i_a2fb022ec7f30053, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<88> b_9e2e784c915329b6 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 182, 41, 83, 145, 76, 120, 46, 158, + 0, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 2, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 110, + 97, 109, 101, 100, 85, 110, 105, 111, + 110, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 254, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 98, 101, 102, 111, 114, 101, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 109, 105, 100, 100, 108, 101, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 102, 116, 101, 114, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_9e2e784c915329b6[] = {4, 3, 0, 1, 2}; +static const uint16_t i_9e2e784c915329b6[] = {1, 3, 0, 2, 4}; +const ::capnp::_::RawSchema s_9e2e784c915329b6 = { + 0x9e2e784c915329b6, b_9e2e784c915329b6.words, 88, nullptr, m_9e2e784c915329b6, + 0, 5, i_9e2e784c915329b6, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<26> b_89a9494f1b900f22 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 34, 15, 144, 27, 79, 73, 169, 137, + 0, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 73, 110, 85, 110, 105, 111, + 110, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 12, 103, 7, 55, 198, 246, 5, 208, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 101, 114, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_89a9494f1b900f22[] = { + &s_d005f6c63707670c, +}; +static const uint16_t m_89a9494f1b900f22[] = {0}; +static const uint16_t i_89a9494f1b900f22[] = {0}; +const ::capnp::_::RawSchema s_89a9494f1b900f22 = { + 0x89a9494f1b900f22, b_89a9494f1b900f22.words, 26, d_89a9494f1b900f22, m_89a9494f1b900f22, + 1, 1, i_89a9494f1b900f22, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<39> b_d005f6c63707670c = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 12, 103, 7, 55, 198, 246, 5, 208, + 34, 0, 0, 0, 1, 0, 2, 0, + 34, 15, 144, 27, 79, 73, 169, 137, + 0, 0, 7, 0, 1, 0, 2, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 73, 110, 85, 110, 105, 111, + 110, 46, 111, 117, 116, 101, 114, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 219, 229, 248, 198, 17, 225, 156, 255, + 41, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 2, 0, 1, 0, + 20, 0, 0, 0, 2, 0, 1, 0, + 105, 110, 110, 101, 114, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_d005f6c63707670c[] = { + &s_89a9494f1b900f22, + &s_ff9ce111c6f8e5db, +}; +static const uint16_t m_d005f6c63707670c[] = {1, 0}; +static const uint16_t i_d005f6c63707670c[] = {0, 1}; +const ::capnp::_::RawSchema s_d005f6c63707670c = { + 0xd005f6c63707670c, b_d005f6c63707670c.words, 39, d_d005f6c63707670c, m_d005f6c63707670c, + 2, 2, i_d005f6c63707670c, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_ff9ce111c6f8e5db = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 219, 229, 248, 198, 17, 225, 156, 255, + 40, 0, 0, 0, 1, 0, 2, 0, + 12, 103, 7, 55, 198, 246, 5, 208, + 0, 0, 7, 0, 1, 0, 2, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 114, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 73, 110, 85, 110, 105, 111, + 110, 46, 111, 117, 116, 101, 114, 46, + 105, 110, 110, 101, 114, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_ff9ce111c6f8e5db[] = { + &s_d005f6c63707670c, +}; +static const uint16_t m_ff9ce111c6f8e5db[] = {1, 0}; +static const uint16_t i_ff9ce111c6f8e5db[] = {0, 1}; +const ::capnp::_::RawSchema s_ff9ce111c6f8e5db = { + 0xff9ce111c6f8e5db, b_ff9ce111c6f8e5db.words, 46, d_ff9ce111c6f8e5db, m_ff9ce111c6f8e5db, + 1, 2, i_ff9ce111c6f8e5db, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<25> b_dc841556134c3103 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 3, 49, 76, 19, 86, 21, 132, 220, + 0, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 226, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 71, 114, 111, + 117, 112, 115, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 13, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 111, 117, 112, 115, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_dc841556134c3103[] = { + &s_e22ae74ff9113268, +}; +static const uint16_t m_dc841556134c3103[] = {0}; +static const uint16_t i_dc841556134c3103[] = {0}; +const ::capnp::_::RawSchema s_dc841556134c3103 = { + 0xdc841556134c3103, b_dc841556134c3103.words, 25, d_dc841556134c3103, m_dc841556134c3103, + 1, 1, i_dc841556134c3103, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<41> b_e22ae74ff9113268 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 28, 0, 0, 0, 1, 0, 2, 0, + 3, 49, 76, 19, 86, 21, 132, 220, + 2, 0, 7, 0, 1, 0, 3, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 26, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 71, 114, 111, + 117, 112, 115, 46, 103, 114, 111, 117, + 112, 115, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 111, 25, 193, 192, 137, 186, 252, 245, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 254, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 179, 164, 102, 64, 48, 48, 250, 240, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 253, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 26, 9, 208, 192, 39, 183, + 21, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_e22ae74ff9113268[] = { + &s_b727c0d0091a001d, + &s_dc841556134c3103, + &s_f0fa30304066a4b3, + &s_f5fcba89c0c1196f, +}; +static const uint16_t m_e22ae74ff9113268[] = {2, 1, 0}; +static const uint16_t i_e22ae74ff9113268[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_e22ae74ff9113268 = { + 0xe22ae74ff9113268, b_e22ae74ff9113268.words, 41, d_e22ae74ff9113268, m_e22ae74ff9113268, + 4, 3, i_e22ae74ff9113268, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<59> b_f5fcba89c0c1196f = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 111, 25, 193, 192, 137, 186, 252, 245, + 35, 0, 0, 0, 1, 0, 2, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 2, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 58, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 71, 114, 111, + 117, 112, 115, 46, 103, 114, 111, 117, + 112, 115, 46, 102, 111, 111, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_f5fcba89c0c1196f[] = { + &s_e22ae74ff9113268, +}; +static const uint16_t m_f5fcba89c0c1196f[] = {0, 2, 1}; +static const uint16_t i_f5fcba89c0c1196f[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_f5fcba89c0c1196f = { + 0xf5fcba89c0c1196f, b_f5fcba89c0c1196f.words, 59, d_f5fcba89c0c1196f, m_f5fcba89c0c1196f, + 1, 3, i_f5fcba89c0c1196f, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<59> b_f0fa30304066a4b3 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 179, 164, 102, 64, 48, 48, 250, 240, + 35, 0, 0, 0, 1, 0, 2, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 2, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 58, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 71, 114, 111, + 117, 112, 115, 46, 103, 114, 111, 117, + 112, 115, 46, 98, 97, 122, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_f0fa30304066a4b3[] = { + &s_e22ae74ff9113268, +}; +static const uint16_t m_f0fa30304066a4b3[] = {0, 2, 1}; +static const uint16_t i_f0fa30304066a4b3[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_f0fa30304066a4b3 = { + 0xf0fa30304066a4b3, b_f0fa30304066a4b3.words, 59, d_f0fa30304066a4b3, m_f0fa30304066a4b3, + 1, 3, i_f0fa30304066a4b3, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<59> b_b727c0d0091a001d = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 29, 0, 26, 9, 208, 192, 39, 183, + 35, 0, 0, 0, 1, 0, 2, 0, + 104, 50, 17, 249, 79, 231, 42, 226, + 2, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 58, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 71, 114, 111, + 117, 112, 115, 46, 103, 114, 111, 117, + 112, 115, 46, 98, 97, 114, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_b727c0d0091a001d[] = { + &s_e22ae74ff9113268, +}; +static const uint16_t m_b727c0d0091a001d[] = {0, 2, 1}; +static const uint16_t i_b727c0d0091a001d[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_b727c0d0091a001d = { + 0xb727c0d0091a001d, b_b727c0d0091a001d.words, 59, d_b727c0d0091a001d, m_b727c0d0091a001d, + 1, 3, i_b727c0d0091a001d, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<34> b_f77ed6f7454eec40 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 64, 236, 78, 69, 247, 214, 126, 247, + 0, 0, 0, 0, 1, 0, 6, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 6, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 58, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 108, 101, 97, 118, 101, 100, + 71, 114, 111, 117, 112, 115, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 200, 211, 199, 22, 53, 90, 72, 199, + 41, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 233, 144, 153, 86, 53, 163, 133, 204, + 17, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 111, 117, 112, 49, 0, 0, + 103, 114, 111, 117, 112, 50, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_f77ed6f7454eec40[] = { + &s_c7485a3516c7d3c8, + &s_cc85a335569990e9, +}; +static const uint16_t m_f77ed6f7454eec40[] = {0, 1}; +static const uint16_t i_f77ed6f7454eec40[] = {0, 1}; +const ::capnp::_::RawSchema s_f77ed6f7454eec40 = { + 0xf77ed6f7454eec40, b_f77ed6f7454eec40.words, 34, d_f77ed6f7454eec40, m_f77ed6f7454eec40, + 2, 2, i_f77ed6f7454eec40, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<96> b_c7485a3516c7d3c8 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 200, 211, 199, 22, 53, 90, 72, 199, + 39, 0, 0, 0, 1, 0, 6, 0, + 64, 236, 78, 69, 247, 214, 126, 247, + 6, 0, 7, 0, 1, 0, 3, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 114, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 87, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 108, 101, 97, 118, 101, 100, + 71, 114, 111, 117, 112, 115, 46, 103, + 114, 111, 117, 112, 49, 0, 0, 0, + 24, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 156, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 156, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 255, 255, 12, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 156, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 58, 49, 74, 63, 65, 253, 10, 219, + 153, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 2, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 253, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 12, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 2, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_c7485a3516c7d3c8[] = { + &s_db0afd413f4a313a, + &s_f77ed6f7454eec40, +}; +static const uint16_t m_c7485a3516c7d3c8[] = {1, 3, 0, 5, 2, 4}; +static const uint16_t i_c7485a3516c7d3c8[] = {2, 3, 5, 0, 1, 4}; +const ::capnp::_::RawSchema s_c7485a3516c7d3c8 = { + 0xc7485a3516c7d3c8, b_c7485a3516c7d3c8.words, 96, d_c7485a3516c7d3c8, m_c7485a3516c7d3c8, + 2, 6, i_c7485a3516c7d3c8, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<75> b_db0afd413f4a313a = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 58, 49, 74, 63, 65, 253, 10, 219, + 46, 0, 0, 0, 1, 0, 6, 0, + 200, 211, 199, 22, 53, 90, 72, 199, + 6, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 162, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 108, 101, 97, 118, 101, 100, + 71, 114, 111, 117, 112, 115, 46, 103, + 114, 111, 117, 112, 49, 46, 99, 111, + 114, 103, 101, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 12, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 14, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 16, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_db0afd413f4a313a[] = { + &s_c7485a3516c7d3c8, +}; +static const uint16_t m_db0afd413f4a313a[] = {1, 0, 2, 3}; +static const uint16_t i_db0afd413f4a313a[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_db0afd413f4a313a = { + 0xdb0afd413f4a313a, b_db0afd413f4a313a.words, 75, d_db0afd413f4a313a, m_db0afd413f4a313a, + 1, 4, i_db0afd413f4a313a, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<96> b_cc85a335569990e9 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 233, 144, 153, 86, 53, 163, 133, 204, + 39, 0, 0, 0, 1, 0, 6, 0, + 64, 236, 78, 69, 247, 214, 126, 247, + 6, 0, 7, 0, 1, 0, 3, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 114, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 87, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 108, 101, 97, 118, 101, 100, + 71, 114, 111, 117, 112, 115, 46, 103, + 114, 111, 117, 112, 50, 0, 0, 0, + 24, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 156, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 156, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 255, 255, 13, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 153, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 156, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 254, 255, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 55, 238, 39, 104, 54, 240, 23, 160, + 153, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 11, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 2, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 253, 255, 3, 0, 0, 0, + 0, 0, 1, 0, 13, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 129, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 124, 0, 0, 0, 2, 0, 1, 0, + 132, 0, 0, 0, 2, 0, 1, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_cc85a335569990e9[] = { + &s_a017f0366827ee37, + &s_f77ed6f7454eec40, +}; +static const uint16_t m_cc85a335569990e9[] = {1, 3, 0, 5, 2, 4}; +static const uint16_t i_cc85a335569990e9[] = {2, 3, 5, 0, 1, 4}; +const ::capnp::_::RawSchema s_cc85a335569990e9 = { + 0xcc85a335569990e9, b_cc85a335569990e9.words, 96, d_cc85a335569990e9, m_cc85a335569990e9, + 2, 6, i_cc85a335569990e9, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<75> b_a017f0366827ee37 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 55, 238, 39, 104, 54, 240, 23, 160, + 46, 0, 0, 0, 1, 0, 6, 0, + 233, 144, 153, 86, 53, 163, 133, 204, + 6, 0, 7, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 162, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 108, 101, 97, 118, 101, 100, + 71, 114, 111, 117, 112, 115, 46, 103, + 114, 111, 117, 112, 50, 46, 99, 111, + 114, 103, 101, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 13, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 15, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 17, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 0, 0, 0, 2, 0, 1, 0, + 100, 0, 0, 0, 2, 0, 1, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_a017f0366827ee37[] = { + &s_cc85a335569990e9, +}; +static const uint16_t m_a017f0366827ee37[] = {1, 0, 2, 3}; +static const uint16_t i_a017f0366827ee37[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_a017f0366827ee37 = { + 0xa017f0366827ee37, b_a017f0366827ee37.words, 75, d_a017f0366827ee37, m_a017f0366827ee37, + 1, 4, i_a017f0366827ee37, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<109> b_94f7e0b103b4b718 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 24, 183, 180, 3, 177, 224, 247, 148, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 4, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 26, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 110, 105, + 111, 110, 68, 101, 102, 97, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 96, 0, 0, 0, 2, 0, 1, 0, + 104, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 140, 0, 0, 0, 2, 0, 1, 0, + 148, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 188, 0, 0, 0, 2, 0, 1, 0, + 196, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 209, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 208, 0, 0, 0, 2, 0, 1, 0, + 216, 0, 0, 0, 2, 0, 1, 0, + 115, 49, 54, 115, 56, 115, 54, 52, + 115, 56, 83, 101, 116, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 2, 0, + 3, 0, 3, 0, 4, 0, 1, 0, + 65, 1, 0, 0, 0, 0, 0, 0, + 0, 123, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 55, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 135, 75, 107, 93, 84, 220, 43, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 48, 115, 112, 115, 49, 115, 51, + 50, 83, 101, 116, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 82, 206, 51, 34, 54, 151, 118, 244, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 8, 0, 2, 0, + 7, 0, 11, 0, 0, 0, 3, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 78, 97, 188, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 117, 110, 110, 97, 109, 101, 100, 49, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 182, 41, 83, 145, 76, 120, 46, 158, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 2, 0, + 123, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 110, 110, 97, 109, 101, 100, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 182, 41, 83, 145, 76, 120, 46, 158, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 2, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 65, 1, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_94f7e0b103b4b718[] = { + &s_9e2e784c915329b6, + &s_f47697362233ce52, +}; +static const uint16_t m_94f7e0b103b4b718[] = {1, 0, 2, 3}; +static const uint16_t i_94f7e0b103b4b718[] = {0, 1, 2, 3}; +const ::capnp::_::RawSchema s_94f7e0b103b4b718 = { + 0x94f7e0b103b4b718, b_94f7e0b103b4b718.words, 109, d_94f7e0b103b4b718, m_94f7e0b103b4b718, + 2, 4, i_94f7e0b103b4b718, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<71> b_d9f2b5941a343bcd = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 205, 59, 52, 26, 148, 181, 242, 217, + 0, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 10, 1, 0, 0, + 33, 0, 0, 0, 39, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 61, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 78, 101, 115, + 116, 101, 100, 84, 121, 112, 101, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 1, 0, 1, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 9, 0, 0, 0, 90, 0, 0, 0, + 107, 215, 41, 59, 165, 3, 205, 130, + 9, 0, 0, 0, 106, 0, 0, 0, + 78, 101, 115, 116, 101, 100, 69, 110, + 117, 109, 0, 0, 0, 0, 0, 0, + 78, 101, 115, 116, 101, 100, 83, 116, + 114, 117, 99, 116, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 2, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 110, 101, 115, 116, 101, 100, 83, 116, + 114, 117, 99, 116, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 107, 215, 41, 59, 165, 3, 205, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_d9f2b5941a343bcd[] = { + &s_82cd03a53b29d76b, + &s_b651d2fba42056d4, + &s_cfa0d546993a3df3, +}; +static const uint16_t m_d9f2b5941a343bcd[] = {2, 0, 1}; +static const uint16_t i_d9f2b5941a343bcd[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_d9f2b5941a343bcd = { + 0xd9f2b5941a343bcd, b_d9f2b5941a343bcd.words, 71, d_d9f2b5941a343bcd, m_d9f2b5941a343bcd, + 3, 3, i_d9f2b5941a343bcd, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<27> b_b651d2fba42056d4 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 0, 0, 0, 0, 2, 0, 0, 0, + 205, 59, 52, 26, 148, 181, 242, 217, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 98, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 55, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 78, 101, 115, + 116, 101, 100, 84, 121, 112, 101, 115, + 46, 78, 101, 115, 116, 101, 100, 69, + 110, 117, 109, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_b651d2fba42056d4[] = {1, 0}; +const ::capnp::_::RawSchema s_b651d2fba42056d4 = { + 0xb651d2fba42056d4, b_b651d2fba42056d4.words, 27, nullptr, m_b651d2fba42056d4, + 0, 2, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<53> b_82cd03a53b29d76b = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 107, 215, 41, 59, 165, 3, 205, 130, + 0, 0, 0, 0, 1, 0, 1, 0, + 205, 59, 52, 26, 148, 181, 242, 217, + 0, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 114, 1, 0, 0, + 37, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 49, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 78, 101, 115, + 116, 101, 100, 84, 121, 112, 101, 115, + 46, 78, 101, 115, 116, 101, 100, 83, + 116, 114, 117, 99, 116, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 1, 0, 0, 0, 90, 0, 0, 0, + 78, 101, 115, 116, 101, 100, 69, 110, + 117, 109, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 111, 117, 116, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 110, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_82cd03a53b29d76b[] = { + &s_b651d2fba42056d4, + &s_cfa0d546993a3df3, +}; +static const uint16_t m_82cd03a53b29d76b[] = {1, 0}; +static const uint16_t i_82cd03a53b29d76b[] = {0, 1}; +const ::capnp::_::RawSchema s_82cd03a53b29d76b = { + 0x82cd03a53b29d76b, b_82cd03a53b29d76b.words, 53, d_82cd03a53b29d76b, m_82cd03a53b29d76b, + 2, 2, i_82cd03a53b29d76b, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<33> b_cfa0d546993a3df3 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 0, 0, 0, 0, 2, 0, 0, 0, + 107, 215, 41, 59, 165, 3, 205, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 202, 1, 0, 0, + 45, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 79, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 78, 101, 115, + 116, 101, 100, 84, 121, 112, 101, 115, + 46, 78, 101, 115, 116, 101, 100, 83, + 116, 114, 117, 99, 116, 46, 78, 101, + 115, 116, 101, 100, 69, 110, 117, 109, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, } +}; +static const uint16_t m_cfa0d546993a3df3[] = {0, 2, 1}; +const ::capnp::_::RawSchema s_cfa0d546993a3df3 = { + 0xcfa0d546993a3df3, b_cfa0d546993a3df3.words, 33, nullptr, m_cfa0d546993a3df3, + 0, 3, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<47> b_e78aac389e77b065 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 101, 176, 119, 158, 56, 172, 138, 231, + 0, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 218, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 85, 115, 105, + 110, 103, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 130, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 105, 110, 110, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 243, 61, 58, 153, 70, 213, 160, 207, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 101, 114, 78, 101, 115, + 116, 101, 100, 69, 110, 117, 109, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 212, 86, 32, 164, 251, 210, 81, 182, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_e78aac389e77b065[] = { + &s_b651d2fba42056d4, + &s_cfa0d546993a3df3, +}; +static const uint16_t m_e78aac389e77b065[] = {0, 1}; +static const uint16_t i_e78aac389e77b065[] = {0, 1}; +const ::capnp::_::RawSchema s_e78aac389e77b065 = { + 0xe78aac389e77b065, b_e78aac389e77b065.words, 47, d_e78aac389e77b065, m_e78aac389e77b065, + 2, 2, i_e78aac389e77b065, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<251> b_e41885c94393277e = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 10, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 218, 0, 0, 0, + 29, 0, 0, 0, 231, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 233, 0, 0, 0, 55, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 0, 0, 0, 0, 0, 0, + 56, 0, 0, 0, 1, 0, 1, 0, + 238, 207, 178, 117, 59, 192, 18, 132, + 105, 0, 0, 0, 66, 0, 0, 0, + 105, 173, 65, 177, 112, 88, 254, 224, + 101, 0, 0, 0, 66, 0, 0, 0, + 91, 20, 144, 48, 53, 26, 65, 166, + 97, 0, 0, 0, 66, 0, 0, 0, + 108, 152, 40, 41, 168, 247, 171, 168, + 93, 0, 0, 0, 74, 0, 0, 0, + 66, 7, 211, 78, 220, 238, 123, 173, + 93, 0, 0, 0, 74, 0, 0, 0, + 70, 198, 124, 255, 242, 52, 154, 239, + 93, 0, 0, 0, 74, 0, 0, 0, + 39, 98, 158, 50, 176, 241, 171, 198, + 93, 0, 0, 0, 66, 0, 0, 0, + 106, 177, 54, 163, 76, 35, 58, 148, + 89, 0, 0, 0, 74, 0, 0, 0, + 205, 148, 165, 116, 14, 188, 145, 137, + 89, 0, 0, 0, 74, 0, 0, 0, + 36, 122, 140, 82, 22, 116, 38, 237, + 89, 0, 0, 0, 74, 0, 0, 0, + 230, 88, 125, 3, 123, 131, 120, 153, + 89, 0, 0, 0, 82, 0, 0, 0, + 4, 121, 74, 245, 64, 169, 95, 237, + 89, 0, 0, 0, 82, 0, 0, 0, + 125, 124, 89, 242, 120, 55, 116, 188, + 89, 0, 0, 0, 82, 0, 0, 0, + 61, 1, 130, 1, 164, 100, 227, 194, + 89, 0, 0, 0, 74, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 48, 0, + 83, 116, 114, 117, 99, 116, 49, 0, + 83, 116, 114, 117, 99, 116, 56, 0, + 83, 116, 114, 117, 99, 116, 49, 54, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 51, 50, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 54, 52, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 80, 0, + 83, 116, 114, 117, 99, 116, 48, 99, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 49, 99, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 56, 99, + 0, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 49, 54, + 99, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 51, 50, + 99, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 54, 52, + 99, 0, 0, 0, 0, 0, 0, 0, + 83, 116, 114, 117, 99, 116, 80, 99, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 1, 0, 0, 2, 0, 1, 0, + 24, 1, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 21, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 1, 0, 0, 2, 0, 1, 0, + 36, 1, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 1, 0, 0, 2, 0, 1, 0, + 48, 1, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 1, 0, 0, 2, 0, 1, 0, + 60, 1, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 4, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 57, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 52, 1, 0, 0, 2, 0, 1, 0, + 72, 1, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 5, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 1, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 1, 0, 0, 2, 0, 1, 0, + 84, 1, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 6, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 81, 1, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 1, 0, 0, 2, 0, 1, 0, + 96, 1, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 1, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 1, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 92, 1, 0, 0, 2, 0, 1, 0, + 124, 1, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 8, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 121, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 1, 0, 0, 2, 0, 1, 0, + 152, 1, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 149, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 148, 1, 0, 0, 2, 0, 1, 0, + 180, 1, 0, 0, 2, 0, 1, 0, + 108, 105, 115, 116, 48, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 238, 207, 178, 117, 59, 192, 18, 132, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 49, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 105, 173, 65, 177, 112, 88, 254, 224, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 56, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 91, 20, 144, 48, 53, 26, 65, 166, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 49, 54, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 108, 152, 40, 41, 168, 247, 171, 168, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 51, 50, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 66, 7, 211, 78, 220, 238, 123, 173, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 54, 52, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 70, 198, 124, 255, 242, 52, 154, 239, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 80, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 39, 98, 158, 50, 176, 241, 171, 198, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 76, 105, 115, 116, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 76, 105, 115, 116, + 76, 105, 115, 116, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 76, 105, 115, 116, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_e41885c94393277e[] = { + &s_8412c03b75b2cfee, + &s_a0a8f314b80b63fd, + &s_a6411a353090145b, + &s_a8abf7a82928986c, + &s_ad7beedc4ed30742, + &s_c6abf1b0329e6227, + &s_e0fe5870b141ad69, + &s_ef9a34f2ff7cc646, +}; +static const uint16_t m_e41885c94393277e[] = {7, 0, 1, 3, 4, 5, 2, 6, 9, 8}; +static const uint16_t i_e41885c94393277e[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; +const ::capnp::_::RawSchema s_e41885c94393277e = { + 0xe41885c94393277e, b_e41885c94393277e.words, 251, d_e41885c94393277e, m_e41885c94393277e, + 8, 10, i_e41885c94393277e, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_8412c03b75b2cfee = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 238, 207, 178, 117, 59, 192, 18, 132, + 0, 0, 0, 0, 1, 0, 0, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 26, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 48, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_8412c03b75b2cfee[] = {0}; +static const uint16_t i_8412c03b75b2cfee[] = {0}; +const ::capnp::_::RawSchema s_8412c03b75b2cfee = { + 0x8412c03b75b2cfee, b_8412c03b75b2cfee.words, 32, nullptr, m_8412c03b75b2cfee, + 0, 1, i_8412c03b75b2cfee, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_e0fe5870b141ad69 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 105, 173, 65, 177, 112, 88, 254, 224, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 26, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 49, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_e0fe5870b141ad69[] = {0}; +static const uint16_t i_e0fe5870b141ad69[] = {0}; +const ::capnp::_::RawSchema s_e0fe5870b141ad69 = { + 0xe0fe5870b141ad69, b_e0fe5870b141ad69.words, 32, nullptr, m_e0fe5870b141ad69, + 0, 1, i_e0fe5870b141ad69, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_a6411a353090145b = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 91, 20, 144, 48, 53, 26, 65, 166, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 26, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 56, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_a6411a353090145b[] = {0}; +static const uint16_t i_a6411a353090145b[] = {0}; +const ::capnp::_::RawSchema s_a6411a353090145b = { + 0xa6411a353090145b, b_a6411a353090145b.words, 32, nullptr, m_a6411a353090145b, + 0, 1, i_a6411a353090145b, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_a8abf7a82928986c = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 108, 152, 40, 41, 168, 247, 171, 168, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 49, 54, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_a8abf7a82928986c[] = {0}; +static const uint16_t i_a8abf7a82928986c[] = {0}; +const ::capnp::_::RawSchema s_a8abf7a82928986c = { + 0xa8abf7a82928986c, b_a8abf7a82928986c.words, 32, nullptr, m_a8abf7a82928986c, + 0, 1, i_a8abf7a82928986c, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_ad7beedc4ed30742 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 66, 7, 211, 78, 220, 238, 123, 173, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 51, 50, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_ad7beedc4ed30742[] = {0}; +static const uint16_t i_ad7beedc4ed30742[] = {0}; +const ::capnp::_::RawSchema s_ad7beedc4ed30742 = { + 0xad7beedc4ed30742, b_ad7beedc4ed30742.words, 32, nullptr, m_ad7beedc4ed30742, + 0, 1, i_ad7beedc4ed30742, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_ef9a34f2ff7cc646 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 70, 198, 124, 255, 242, 52, 154, 239, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 54, 52, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_ef9a34f2ff7cc646[] = {0}; +static const uint16_t i_ef9a34f2ff7cc646[] = {0}; +const ::capnp::_::RawSchema s_ef9a34f2ff7cc646 = { + 0xef9a34f2ff7cc646, b_ef9a34f2ff7cc646.words, 32, nullptr, m_ef9a34f2ff7cc646, + 0, 1, i_ef9a34f2ff7cc646, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_c6abf1b0329e6227 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 39, 98, 158, 50, 176, 241, 171, 198, + 0, 0, 0, 0, 1, 0, 0, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 26, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 80, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_c6abf1b0329e6227[] = {0}; +static const uint16_t i_c6abf1b0329e6227[] = {0}; +const ::capnp::_::RawSchema s_c6abf1b0329e6227 = { + 0xc6abf1b0329e6227, b_c6abf1b0329e6227.words, 32, nullptr, m_c6abf1b0329e6227, + 0, 1, i_c6abf1b0329e6227, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_943a234ca336b16a = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 106, 177, 54, 163, 76, 35, 58, 148, + 0, 0, 0, 0, 1, 0, 0, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 48, 99, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_943a234ca336b16a[] = {0, 1}; +static const uint16_t i_943a234ca336b16a[] = {0, 1}; +const ::capnp::_::RawSchema s_943a234ca336b16a = { + 0x943a234ca336b16a, b_943a234ca336b16a.words, 46, nullptr, m_943a234ca336b16a, + 0, 2, i_943a234ca336b16a, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_8991bc0e74a594cd = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 205, 148, 165, 116, 14, 188, 145, 137, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 49, 99, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_8991bc0e74a594cd[] = {0, 1}; +static const uint16_t i_8991bc0e74a594cd[] = {0, 1}; +const ::capnp::_::RawSchema s_8991bc0e74a594cd = { + 0x8991bc0e74a594cd, b_8991bc0e74a594cd.words, 46, nullptr, m_8991bc0e74a594cd, + 0, 2, i_8991bc0e74a594cd, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_ed267416528c7a24 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 36, 122, 140, 82, 22, 116, 38, 237, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 56, 99, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_ed267416528c7a24[] = {0, 1}; +static const uint16_t i_ed267416528c7a24[] = {0, 1}; +const ::capnp::_::RawSchema s_ed267416528c7a24 = { + 0xed267416528c7a24, b_ed267416528c7a24.words, 46, nullptr, m_ed267416528c7a24, + 0, 2, i_ed267416528c7a24, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_9978837b037d58e6 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 230, 88, 125, 3, 123, 131, 120, 153, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 42, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 49, 54, 99, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_9978837b037d58e6[] = {0, 1}; +static const uint16_t i_9978837b037d58e6[] = {0, 1}; +const ::capnp::_::RawSchema s_9978837b037d58e6 = { + 0x9978837b037d58e6, b_9978837b037d58e6.words, 46, nullptr, m_9978837b037d58e6, + 0, 2, i_9978837b037d58e6, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_ed5fa940f54a7904 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 4, 121, 74, 245, 64, 169, 95, 237, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 42, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 51, 50, 99, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_ed5fa940f54a7904[] = {0, 1}; +static const uint16_t i_ed5fa940f54a7904[] = {0, 1}; +const ::capnp::_::RawSchema s_ed5fa940f54a7904 = { + 0xed5fa940f54a7904, b_ed5fa940f54a7904.words, 46, nullptr, m_ed5fa940f54a7904, + 0, 2, i_ed5fa940f54a7904, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_bc743778f2597c7d = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 125, 124, 89, 242, 120, 55, 116, 188, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 42, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 54, 52, 99, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_bc743778f2597c7d[] = {0, 1}; +static const uint16_t i_bc743778f2597c7d[] = {0, 1}; +const ::capnp::_::RawSchema s_bc743778f2597c7d = { + 0xbc743778f2597c7d, b_bc743778f2597c7d.words, 46, nullptr, m_bc743778f2597c7d, + 0, 2, i_bc743778f2597c7d, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_c2e364a40182013d = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 61, 1, 130, 1, 164, 100, 227, 194, + 0, 0, 0, 0, 1, 0, 1, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 115, 46, 83, 116, 114, 117, 99, + 116, 80, 99, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 102, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 112, 97, 100, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_c2e364a40182013d[] = {0, 1}; +static const uint16_t i_c2e364a40182013d[] = {0, 1}; +const ::capnp::_::RawSchema s_c2e364a40182013d = { + 0xc2e364a40182013d, b_c2e364a40182013d.words, 46, nullptr, m_c2e364a40182013d, + 0, 2, i_c2e364a40182013d, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<62> b_92fc29a80f3ddd5c = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 92, 221, 61, 15, 168, 41, 252, 146, + 0, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 70, 105, 101, + 108, 100, 90, 101, 114, 111, 73, 115, + 66, 105, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 82, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 68, 0, 0, 0, 2, 0, 1, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 73, 0, 0, 0, 90, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 80, 0, 0, 0, 2, 0, 1, 0, + 98, 105, 116, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 101, 99, 111, 110, 100, 66, 105, + 116, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 104, 105, 114, 100, 70, 105, 101, + 108, 100, 0, 0, 0, 0, 0, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 123, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_92fc29a80f3ddd5c[] = {0, 1, 2}; +static const uint16_t i_92fc29a80f3ddd5c[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_92fc29a80f3ddd5c = { + 0x92fc29a80f3ddd5c, b_92fc29a80f3ddd5c.words, 62, nullptr, m_92fc29a80f3ddd5c, + 0, 3, i_92fc29a80f3ddd5c, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<154> b_a851ad32cbc2ffea = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 234, 255, 194, 203, 50, 173, 81, 168, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 105, 115, + 116, 68, 101, 102, 97, 117, 108, 116, + 115, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 108, 105, 115, 116, 115, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 126, 39, 147, 67, 201, 133, 24, 228, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 10, 0, + 37, 0, 0, 0, 16, 0, 0, 0, + 33, 0, 0, 0, 33, 0, 0, 0, + 33, 0, 0, 0, 18, 0, 0, 0, + 33, 0, 0, 0, 19, 0, 0, 0, + 33, 0, 0, 0, 20, 0, 0, 0, + 33, 0, 0, 0, 21, 0, 0, 0, + 37, 0, 0, 0, 22, 0, 0, 0, + 49, 0, 0, 0, 30, 0, 0, 0, + 73, 0, 0, 0, 30, 0, 0, 0, + 121, 0, 0, 0, 22, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 123, 45, 0, 0, 0, 0, 0, 0, + 57, 48, 133, 26, 0, 0, 0, 0, + 21, 205, 91, 7, 210, 56, 251, 13, + 192, 186, 138, 60, 213, 98, 4, 0, + 135, 75, 170, 237, 97, 85, 8, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 28, 0, 0, 0, + 13, 0, 0, 0, 20, 0, 0, 0, + 13, 0, 0, 0, 12, 0, 0, 0, + 1, 0, 0, 0, 2, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 5, 0, 0, 0, + 242, 79, 188, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 22, 0, 0, 0, + 21, 0, 0, 0, 14, 0, 0, 0, + 25, 0, 0, 0, 22, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 34, 0, 0, 0, + 5, 0, 0, 0, 50, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 5, 0, 0, 0, 167, 1, 0, 0, + 213, 0, 0, 0, 215, 0, 0, 0, + 8, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 123, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 200, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 21, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_a851ad32cbc2ffea[] = { + &s_e41885c94393277e, +}; +static const uint16_t m_a851ad32cbc2ffea[] = {0}; +static const uint16_t i_a851ad32cbc2ffea[] = {0}; +const ::capnp::_::RawSchema s_a851ad32cbc2ffea = { + 0xa851ad32cbc2ffea, b_a851ad32cbc2ffea.words, 154, d_a851ad32cbc2ffea, m_a851ad32cbc2ffea, + 1, 1, i_a851ad32cbc2ffea, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<77> b_a76e3c9bb7fd56d3 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 211, 86, 253, 183, 155, 60, 110, 167, + 0, 0, 0, 0, 1, 0, 3, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 3, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 250, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 97, 116, + 101, 85, 110, 105, 111, 110, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 3, 0, 0, 0, + 121, 160, 26, 144, 162, 128, 114, 128, + 125, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 7, 0, 0, 0, + 58, 142, 233, 222, 132, 57, 151, 193, + 105, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 104, 101, 85, 110, 105, 111, 110, + 0, 0, 0, 0, 0, 0, 0, 0, + 97, 110, 111, 116, 104, 101, 114, 85, + 110, 105, 111, 110, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_a76e3c9bb7fd56d3[] = { + &s_807280a2901aa079, + &s_c1973984dee98e3a, +}; +static const uint16_t m_a76e3c9bb7fd56d3[] = {4, 1, 2, 0, 3}; +static const uint16_t i_a76e3c9bb7fd56d3[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_a76e3c9bb7fd56d3 = { + 0xa76e3c9bb7fd56d3, b_a76e3c9bb7fd56d3.words, 77, d_a76e3c9bb7fd56d3, m_a76e3c9bb7fd56d3, + 2, 5, i_a76e3c9bb7fd56d3, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<62> b_807280a2901aa079 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 121, 160, 26, 144, 162, 128, 114, 128, + 31, 0, 0, 0, 1, 0, 3, 0, + 211, 86, 253, 183, 155, 60, 110, 167, + 3, 0, 7, 0, 1, 0, 3, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 97, 116, + 101, 85, 110, 105, 111, 110, 46, 116, + 104, 101, 85, 110, 105, 111, 110, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 1, 0, 0, 0, + 0, 0, 1, 0, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_807280a2901aa079[] = { + &s_a76e3c9bb7fd56d3, +}; +static const uint16_t m_807280a2901aa079[] = {1, 2, 0}; +static const uint16_t i_807280a2901aa079[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_807280a2901aa079 = { + 0x807280a2901aa079, b_807280a2901aa079.words, 62, d_807280a2901aa079, m_807280a2901aa079, + 1, 3, i_807280a2901aa079, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<63> b_c1973984dee98e3a = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 58, 142, 233, 222, 132, 57, 151, 193, + 31, 0, 0, 0, 1, 0, 3, 0, + 211, 86, 253, 183, 155, 60, 110, 167, + 3, 0, 7, 0, 1, 0, 3, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 98, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 76, 97, 116, + 101, 85, 110, 105, 111, 110, 46, 97, + 110, 111, 116, 104, 101, 114, 85, 110, + 105, 111, 110, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 8, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 2, 0, 0, 0, + 0, 0, 1, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 253, 255, 4, 0, 0, 0, + 0, 0, 1, 0, 10, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 81, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 76, 0, 0, 0, 2, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_c1973984dee98e3a[] = { + &s_a76e3c9bb7fd56d3, +}; +static const uint16_t m_c1973984dee98e3a[] = {1, 2, 0}; +static const uint16_t i_c1973984dee98e3a[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_c1973984dee98e3a = { + 0xc1973984dee98e3a, b_c1973984dee98e3a.words, 63, d_c1973984dee98e3a, m_c1973984dee98e3a, + 1, 3, i_c1973984dee98e3a, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<59> b_95b30dd14e01dda8 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 168, 221, 1, 78, 209, 13, 179, 149, + 0, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 2, 1, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 79, 108, 100, + 86, 101, 114, 115, 105, 111, 110, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 111, 108, 100, 49, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 108, 100, 50, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 108, 100, 51, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 168, 221, 1, 78, 209, 13, 179, 149, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_95b30dd14e01dda8[] = { + &s_95b30dd14e01dda8, +}; +static const uint16_t m_95b30dd14e01dda8[] = {0, 1, 2}; +static const uint16_t i_95b30dd14e01dda8[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_95b30dd14e01dda8 = { + 0x95b30dd14e01dda8, b_95b30dd14e01dda8.words, 59, d_95b30dd14e01dda8, m_95b30dd14e01dda8, + 1, 3, i_95b30dd14e01dda8, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<88> b_8ed75a7469f04ce3 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 227, 76, 240, 105, 116, 90, 215, 142, + 0, 0, 0, 0, 1, 0, 2, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 3, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 2, 1, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 31, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 78, 101, 119, + 86, 101, 114, 115, 105, 111, 110, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 20, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 125, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 0, 0, 0, 2, 0, 1, 0, + 128, 0, 0, 0, 2, 0, 1, 0, + 111, 108, 100, 49, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 108, 100, 50, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 108, 100, 51, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 227, 76, 240, 105, 116, 90, 215, 142, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 119, 49, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 219, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 119, 50, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_8ed75a7469f04ce3[] = { + &s_8ed75a7469f04ce3, +}; +static const uint16_t m_8ed75a7469f04ce3[] = {3, 4, 0, 1, 2}; +static const uint16_t i_8ed75a7469f04ce3[] = {0, 1, 2, 3, 4}; +const ::capnp::_::RawSchema s_8ed75a7469f04ce3 = { + 0x8ed75a7469f04ce3, b_8ed75a7469f04ce3.words, 88, d_8ed75a7469f04ce3, m_8ed75a7469f04ce3, + 1, 5, i_8ed75a7469f04ce3, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<26> b_faf781ef89a00e39 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 57, 14, 160, 137, 239, 129, 247, 250, + 0, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 10, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 83, 116, 114, + 117, 99, 116, 85, 110, 105, 111, 110, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 60, 90, 239, 123, 103, 220, 46, 153, + 13, 0, 0, 0, 26, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 110, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_faf781ef89a00e39[] = { + &s_992edc677bef5a3c, +}; +static const uint16_t m_faf781ef89a00e39[] = {0}; +static const uint16_t i_faf781ef89a00e39[] = {0}; +const ::capnp::_::RawSchema s_faf781ef89a00e39 = { + 0xfaf781ef89a00e39, b_faf781ef89a00e39.words, 26, d_faf781ef89a00e39, m_faf781ef89a00e39, + 1, 1, i_faf781ef89a00e39, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_992edc677bef5a3c = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 60, 90, 239, 123, 103, 220, 46, 153, + 33, 0, 0, 0, 1, 0, 1, 0, + 57, 14, 160, 137, 239, 129, 247, 250, + 1, 0, 7, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 34, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 83, 116, 114, + 117, 99, 116, 85, 110, 105, 111, 110, + 46, 117, 110, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 255, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 74, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 254, 255, 0, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 45, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 48, 0, 0, 0, 2, 0, 1, 0, + 97, 108, 108, 84, 121, 112, 101, 115, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 98, 106, 101, 99, 116, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 202, 18, 161, 22, 70, 67, 244, 209, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_992edc677bef5a3c[] = { + &s_a0a8f314b80b63fd, + &s_d1f4434616a112ca, + &s_faf781ef89a00e39, +}; +static const uint16_t m_992edc677bef5a3c[] = {0, 1}; +static const uint16_t i_992edc677bef5a3c[] = {0, 1}; +const ::capnp::_::RawSchema s_992edc677bef5a3c = { + 0x992edc677bef5a3c, b_992edc677bef5a3c.words, 46, d_992edc677bef5a3c, m_992edc677bef5a3c, + 3, 2, i_992edc677bef5a3c, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_c5598844441096dc = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 220, 150, 16, 68, 68, 136, 89, 197, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 10, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 69, 109, 112, + 116, 121, 83, 116, 114, 117, 99, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +const ::capnp::_::RawSchema s_c5598844441096dc = { + 0xc5598844441096dc, b_c5598844441096dc.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<146> b_abed745cd8c92095 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 250, 0, 0, 0, + 29, 0, 0, 0, 7, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 0, 0, + 128, 0, 0, 0, 1, 0, 1, 0, + 135, 113, 32, 5, 152, 64, 87, 214, + 249, 0, 0, 0, 82, 0, 0, 0, + 101, 17, 132, 189, 14, 177, 229, 187, + 249, 0, 0, 0, 82, 0, 0, 0, + 134, 237, 173, 160, 96, 135, 191, 228, + 249, 0, 0, 0, 82, 0, 0, 0, + 171, 140, 225, 103, 210, 254, 71, 151, + 249, 0, 0, 0, 90, 0, 0, 0, + 43, 216, 158, 174, 64, 76, 121, 144, + 249, 0, 0, 0, 90, 0, 0, 0, + 107, 243, 255, 157, 144, 76, 131, 193, + 249, 0, 0, 0, 90, 0, 0, 0, + 114, 8, 206, 27, 204, 10, 158, 139, + 249, 0, 0, 0, 90, 0, 0, 0, + 82, 210, 79, 171, 46, 36, 44, 163, + 249, 0, 0, 0, 98, 0, 0, 0, + 213, 57, 70, 193, 47, 71, 197, 185, + 249, 0, 0, 0, 98, 0, 0, 0, + 187, 188, 29, 186, 118, 134, 231, 170, + 249, 0, 0, 0, 98, 0, 0, 0, + 204, 36, 44, 148, 248, 97, 86, 162, + 249, 0, 0, 0, 106, 0, 0, 0, + 72, 92, 178, 177, 186, 148, 33, 219, + 249, 0, 0, 0, 106, 0, 0, 0, + 38, 200, 52, 204, 190, 232, 70, 243, + 249, 0, 0, 0, 82, 0, 0, 0, + 253, 120, 91, 197, 103, 252, 164, 170, + 249, 0, 0, 0, 82, 0, 0, 0, + 122, 21, 241, 75, 65, 212, 55, 237, + 249, 0, 0, 0, 98, 0, 0, 0, + 250, 135, 54, 11, 235, 96, 161, 246, + 249, 0, 0, 0, 82, 0, 0, 0, + 252, 240, 124, 101, 46, 28, 32, 227, + 249, 0, 0, 0, 114, 0, 0, 0, + 220, 140, 16, 78, 200, 16, 24, 206, + 249, 0, 0, 0, 114, 0, 0, 0, + 226, 62, 183, 149, 88, 191, 88, 255, + 249, 0, 0, 0, 114, 0, 0, 0, + 9, 138, 132, 21, 154, 68, 69, 161, + 249, 0, 0, 0, 122, 0, 0, 0, + 13, 191, 180, 182, 67, 167, 103, 165, + 249, 0, 0, 0, 122, 0, 0, 0, + 33, 80, 148, 245, 138, 235, 135, 217, + 249, 0, 0, 0, 122, 0, 0, 0, + 5, 168, 255, 178, 126, 248, 85, 158, + 249, 0, 0, 0, 122, 0, 0, 0, + 76, 127, 83, 215, 71, 17, 77, 254, + 249, 0, 0, 0, 130, 0, 0, 0, + 211, 117, 19, 84, 212, 24, 2, 144, + 249, 0, 0, 0, 130, 0, 0, 0, + 215, 108, 242, 134, 164, 215, 109, 210, + 249, 0, 0, 0, 130, 0, 0, 0, + 101, 160, 128, 133, 19, 117, 184, 254, + 249, 0, 0, 0, 138, 0, 0, 0, + 18, 178, 186, 172, 20, 165, 21, 168, + 253, 0, 0, 0, 138, 0, 0, 0, + 3, 134, 131, 124, 83, 219, 86, 236, + 1, 1, 0, 0, 114, 0, 0, 0, + 88, 20, 50, 182, 93, 120, 104, 196, + 1, 1, 0, 0, 114, 0, 0, 0, + 237, 186, 251, 212, 211, 148, 249, 209, + 1, 1, 0, 0, 130, 0, 0, 0, + 25, 80, 253, 71, 215, 96, 8, 195, + 1, 1, 0, 0, 114, 0, 0, 0, + 118, 111, 105, 100, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 98, 111, 111, 108, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 56, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 49, 54, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 51, 50, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 105, 110, 116, 54, 52, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 117, 105, 110, 116, 56, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 117, 105, 110, 116, 49, 54, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 117, 105, 110, 116, 51, 50, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 117, 105, 110, 116, 54, 52, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 51, 50, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 116, 101, 120, 116, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 100, 97, 116, 97, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 101, 110, 117, 109, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 118, 111, 105, 100, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 98, 111, 111, 108, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 105, 110, 116, 56, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 105, 110, 116, 49, 54, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 105, 110, 116, 54, 52, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 117, 105, 110, 116, 56, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 117, 105, 110, 116, 49, 54, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 117, 105, 110, 116, 51, 50, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 117, 105, 110, 116, 54, 52, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 102, 108, 111, 97, 116, 51, 50, 76, + 105, 115, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 108, 111, 97, 116, 54, 52, 76, + 105, 115, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 120, 116, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 100, 97, 116, 97, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 101, 110, 117, 109, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_abed745cd8c92095 = { + 0xabed745cd8c92095, b_abed745cd8c92095.words, 146, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_d657409805207187 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 135, 113, 32, 5, 152, 64, 87, 214, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 74, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 118, + 111, 105, 100, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_d657409805207187 = { + 0xd657409805207187, b_d657409805207187.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_bbe5b10ebd841165 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 101, 17, 132, 189, 14, 177, 229, 187, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 74, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 98, + 111, 111, 108, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_bbe5b10ebd841165 = { + 0xbbe5b10ebd841165, b_bbe5b10ebd841165.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_e4bf8760a0aded86 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 134, 237, 173, 160, 96, 135, 191, 228, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 74, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 105, + 110, 116, 56, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 133, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_e4bf8760a0aded86 = { + 0xe4bf8760a0aded86, b_e4bf8760a0aded86.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_9747fed267e18cab = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 171, 140, 225, 103, 210, 254, 71, 151, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 82, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 105, + 110, 116, 49, 54, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 199, 207, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_9747fed267e18cab = { + 0x9747fed267e18cab, b_9747fed267e18cab.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_90794c40ae9ed82b = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 43, 216, 158, 174, 64, 76, 121, 144, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 82, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 105, + 110, 116, 51, 50, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 178, 158, 67, 255, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_90794c40ae9ed82b = { + 0x90794c40ae9ed82b, b_90794c40ae9ed82b.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_c1834c909dfff36b = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 107, 243, 255, 157, 144, 76, 131, 193, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 82, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 105, + 110, 116, 54, 52, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 135, 32, 242, 121, 183, 143, 255, 255, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_c1834c909dfff36b = { + 0xc1834c909dfff36b, b_c1834c909dfff36b.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_8b9e0acc1bce0872 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 114, 8, 206, 27, 204, 10, 158, 139, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 82, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 117, + 105, 110, 116, 56, 67, 111, 110, 115, + 116, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 6, 0, 234, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_8b9e0acc1bce0872 = { + 0x8b9e0acc1bce0872, b_8b9e0acc1bce0872.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_a32c242eab4fd252 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 82, 210, 79, 171, 46, 36, 44, 163, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 117, + 105, 110, 116, 49, 54, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 7, 0, 110, 178, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_a32c242eab4fd252 = { + 0xa32c242eab4fd252, b_a32c242eab4fd252.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_b9c5472fc14639d5 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 213, 57, 70, 193, 47, 71, 197, 185, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 117, + 105, 110, 116, 51, 50, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 20, 106, 10, 206, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_b9c5472fc14639d5 = { + 0xb9c5472fc14639d5, b_b9c5472fc14639d5.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_aae78676ba1dbcbb = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 187, 188, 29, 186, 118, 134, 231, 170, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 117, + 105, 110, 116, 54, 52, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 210, 10, 31, 235, 140, 169, 84, 171, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_aae78676ba1dbcbb = { + 0xaae78676ba1dbcbb, b_aae78676ba1dbcbb.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_a25661f8942c24cc = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 204, 36, 44, 148, 248, 97, 86, 162, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 98, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 102, + 108, 111, 97, 116, 51, 50, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 10, 0, 0, 0, 0, 80, 154, 68, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_a25661f8942c24cc = { + 0xa25661f8942c24cc, b_a25661f8942c24cc.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_db2194bab1b25c48 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 72, 92, 178, 177, 186, 148, 33, 219, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 98, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 102, + 108, 111, 97, 116, 54, 52, 67, 111, + 110, 115, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 187, 224, 192, 130, 139, 181, 201, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_db2194bab1b25c48 = { + 0xdb2194bab1b25c48, b_db2194bab1b25c48.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<25> b_f346e8becc34c826 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 38, 200, 52, 204, 190, 232, 70, 243, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 74, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 116, + 101, 120, 116, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 34, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_f346e8becc34c826 = { + 0xf346e8becc34c826, b_f346e8becc34c826.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<25> b_aaa4fc67c55b78fd = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 253, 120, 91, 197, 103, 252, 164, 170, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 74, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 100, + 97, 116, 97, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 26, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_aaa4fc67c55b78fd = { + 0xaaa4fc67c55b78fd, b_aaa4fc67c55b78fd.words, 25, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<231> b_ed37d4414bf1157a = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 122, 21, 241, 75, 65, 212, 55, 237, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 115, + 116, 114, 117, 99, 116, 67, 111, 110, + 115, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_ed37d4414bf1157a = { + 0xed37d4414bf1157a, b_ed37d4414bf1157a.words, 231, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<24> b_f6a160eb0b3687fa = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 250, 135, 54, 11, 235, 96, 161, 246, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 74, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 40, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 101, + 110, 117, 109, 67, 111, 110, 115, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_f6a160eb0b3687fa = { + 0xf6a160eb0b3687fa, b_f6a160eb0b3687fa.words, 24, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<27> b_e3201c2e657cf0fc = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 252, 240, 124, 101, 46, 28, 32, 227, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 106, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 118, + 111, 105, 100, 76, 105, 115, 116, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 48, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_e3201c2e657cf0fc = { + 0xe3201c2e657cf0fc, b_e3201c2e657cf0fc.words, 27, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_ce1810c84e108cdc = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 220, 140, 16, 78, 200, 16, 24, 206, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 106, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 98, + 111, 111, 108, 76, 105, 115, 116, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 33, 0, 0, 0, + 9, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_ce1810c84e108cdc = { + 0xce1810c84e108cdc, b_ce1810c84e108cdc.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_ff58bf5895b73ee2 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 226, 62, 183, 149, 88, 191, 88, 255, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 106, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 105, + 110, 116, 56, 76, 105, 115, 116, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 111, 145, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_ff58bf5895b73ee2 = { + 0xff58bf5895b73ee2, b_ff58bf5895b73ee2.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_a145449a15848a09 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 9, 138, 132, 21, 154, 68, 69, 161, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 114, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 105, + 110, 116, 49, 54, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 103, 43, 153, 212, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_a145449a15848a09 = { + 0xa145449a15848a09, b_a145449a15848a09.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_a567a743b6b4bf0d = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 13, 191, 180, 182, 67, 167, 103, 165, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 114, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 105, + 110, 116, 51, 50, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 4, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 20, 0, 0, 0, + 199, 107, 159, 6, 57, 148, 96, 249, } +}; +const ::capnp::_::RawSchema s_a567a743b6b4bf0d = { + 0xa567a743b6b4bf0d, b_a567a743b6b4bf0d.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<29> b_d987eb8af5945021 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 33, 80, 148, 245, 138, 235, 135, 217, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 114, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 105, + 110, 116, 54, 52, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 5, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 21, 0, 0, 0, + 199, 113, 196, 43, 171, 117, 107, 15, + 57, 142, 59, 212, 84, 138, 148, 240, } +}; +const ::capnp::_::RawSchema s_d987eb8af5945021 = { + 0xd987eb8af5945021, b_d987eb8af5945021.words, 29, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_9e55f87eb2ffa805 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 5, 168, 255, 178, 126, 248, 85, 158, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 114, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 117, + 105, 110, 116, 56, 76, 105, 115, 116, + 67, 111, 110, 115, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 6, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 18, 0, 0, 0, + 111, 222, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_9e55f87eb2ffa805 = { + 0x9e55f87eb2ffa805, b_9e55f87eb2ffa805.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_fe4d1147d7537f4c = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 76, 127, 83, 215, 71, 17, 77, 254, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 122, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 117, + 105, 110, 116, 49, 54, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 7, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 53, 130, 156, 173, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_fe4d1147d7537f4c = { + 0xfe4d1147d7537f4c, b_fe4d1147d7537f4c.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_900218d4541375d3 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 211, 117, 19, 84, 212, 24, 2, 144, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 122, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 117, + 105, 110, 116, 51, 50, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 12, 0, 0, 0, + 85, 161, 174, 198, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_900218d4541375d3 = { + 0x900218d4541375d3, b_900218d4541375d3.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_d26dd7a486f26cd7 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 215, 108, 242, 134, 164, 215, 109, 210, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 122, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 117, + 105, 110, 116, 54, 52, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 9, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 13, 0, 0, 0, + 199, 113, 172, 181, 175, 152, 50, 154, } +}; +const ::capnp::_::RawSchema s_d26dd7a486f26cd7 = { + 0xd26dd7a486f26cd7, b_d26dd7a486f26cd7.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<29> b_feb875138580a065 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 101, 160, 128, 133, 19, 117, 184, 254, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 130, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 102, + 108, 111, 97, 116, 51, 50, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 10, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 36, 0, 0, 0, + 0, 156, 173, 69, 0, 0, 128, 127, + 0, 0, 128, 255, 0, 0, 192, 127, } +}; +const ::capnp::_::RawSchema s_feb875138580a065 = { + 0xfeb875138580a065, b_feb875138580a065.words, 29, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<31> b_a815a514acbab212 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 18, 178, 186, 172, 20, 165, 21, 168, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 130, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 102, + 108, 111, 97, 116, 54, 52, 76, 105, + 115, 116, 67, 111, 110, 115, 116, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 11, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 37, 0, 0, 0, + 0, 0, 0, 0, 192, 97, 190, 64, + 0, 0, 0, 0, 0, 0, 240, 127, + 0, 0, 0, 0, 0, 0, 240, 255, + 0, 0, 0, 0, 0, 0, 248, 127, } +}; +const ::capnp::_::RawSchema s_a815a514acbab212 = { + 0xa815a514acbab212, b_a815a514acbab212.words, 31, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<33> b_ec56db537c838603 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 3, 134, 131, 124, 83, 219, 86, 236, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 106, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 116, + 101, 120, 116, 76, 105, 115, 116, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 30, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 112, 108, 117, 103, 104, 0, 0, 0, + 120, 121, 122, 122, 121, 0, 0, 0, + 116, 104, 117, 100, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_ec56db537c838603 = { + 0xec56db537c838603, b_ec56db537c838603.words, 33, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<34> b_c468785db6321458 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 88, 20, 50, 182, 93, 120, 104, 196, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 106, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 100, + 97, 116, 97, 76, 105, 115, 116, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 13, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 30, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 9, 0, 0, 0, 74, 0, 0, 0, + 13, 0, 0, 0, 58, 0, 0, 0, + 111, 111, 112, 115, 0, 0, 0, 0, + 101, 120, 104, 97, 117, 115, 116, 101, + 100, 0, 0, 0, 0, 0, 0, 0, + 114, 102, 99, 51, 48, 57, 50, 0, } +}; +const ::capnp::_::RawSchema s_c468785db6321458 = { + 0xc468785db6321458, b_c468785db6321458.words, 34, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<112> b_d1f994d3d4fbbaed = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 237, 186, 251, 212, 211, 148, 249, 209, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 122, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 115, + 116, 114, 117, 99, 116, 76, 105, 115, + 116, 67, 111, 110, 115, 116, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 119, 2, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 49, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 50, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 51, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_d1f994d3d4fbbaed = { + 0xd1f994d3d4fbbaed, b_d1f994d3d4fbbaed.words, 112, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<28> b_c30860d747fd5019 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 25, 80, 253, 71, 215, 96, 8, 195, + 0, 0, 0, 0, 4, 0, 0, 0, + 149, 32, 201, 216, 92, 116, 237, 171, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 106, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 52, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 67, 111, 110, + 115, 116, 97, 110, 116, 115, 46, 101, + 110, 117, 109, 76, 105, 115, 116, 67, + 111, 110, 115, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 211, 156, 157, 178, 24, 147, 142, 156, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 19, 0, 0, 0, + 0, 0, 7, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_c30860d747fd5019 = { + 0xc30860d747fd5019, b_c30860d747fd5019.words, 28, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<22> b_ca4028a84b8fc2ed = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 237, 194, 143, 75, 168, 40, 64, 202, + 0, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 218, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 2, 0, 1, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 103, 108, 111, 98, 97, 108, 73, + 110, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 57, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_ca4028a84b8fc2ed = { + 0xca4028a84b8fc2ed, b_ca4028a84b8fc2ed.words, 22, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<23> b_d81b65e268fb3f34 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 52, 63, 251, 104, 226, 101, 27, 216, + 0, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 226, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 2, 0, 1, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 103, 108, 111, 98, 97, 108, 84, + 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 58, 0, 0, 0, + 102, 111, 111, 98, 97, 114, 0, 0, } +}; +const ::capnp::_::RawSchema s_d81b65e268fb3f34 = { + 0xd81b65e268fb3f34, b_d81b65e268fb3f34.words, 23, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<48> b_bd579b448bfbcc7b = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 123, 204, 251, 139, 68, 155, 87, 189, + 0, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 242, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 24, 0, 0, 0, 2, 0, 1, 0, + 32, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 103, 108, 111, 98, 97, 108, 83, + 116, 114, 117, 99, 116, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 49, 212, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_bd579b448bfbcc7b = { + 0xbd579b448bfbcc7b, b_bd579b448bfbcc7b.words, 48, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<343> b_a4764c3483341eeb = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 235, 30, 52, 131, 52, 76, 118, 164, + 0, 0, 0, 0, 4, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 10, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 28, 0, 0, 0, 2, 0, 1, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 100, 101, 114, 105, 118, 101, 100, + 67, 111, 110, 115, 116, 97, 110, 116, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 57, 48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 117, 3, 0, 0, 19, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 3, 0, 0, 119, 2, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 1, 244, 128, 13, 14, 16, 76, 251, + 78, 115, 232, 56, 166, 51, 0, 0, + 90, 0, 210, 4, 20, 136, 98, 3, + 210, 10, 111, 18, 33, 25, 204, 4, + 95, 112, 9, 175, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 144, 117, 64, + 77, 0, 0, 0, 34, 0, 0, 0, + 77, 0, 0, 0, 26, 0, 0, 0, + 76, 0, 0, 0, 6, 0, 20, 0, + 37, 1, 0, 0, 24, 0, 0, 0, + 33, 1, 0, 0, 41, 0, 0, 0, + 33, 1, 0, 0, 34, 0, 0, 0, + 33, 1, 0, 0, 35, 0, 0, 0, + 33, 1, 0, 0, 36, 0, 0, 0, + 37, 1, 0, 0, 37, 0, 0, 0, + 49, 1, 0, 0, 34, 0, 0, 0, + 49, 1, 0, 0, 35, 0, 0, 0, + 49, 1, 0, 0, 36, 0, 0, 0, + 53, 1, 0, 0, 37, 0, 0, 0, + 65, 1, 0, 0, 52, 0, 0, 0, + 73, 1, 0, 0, 53, 0, 0, 0, + 93, 1, 0, 0, 30, 0, 0, 0, + 113, 1, 0, 0, 30, 0, 0, 0, + 133, 1, 0, 0, 119, 2, 0, 0, + 213, 2, 0, 0, 27, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 72, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 110, 101, 115, 116, 101, 100, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 77, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 114, 101, 97, 108, 108, 121, 32, 110, + 101, 115, 116, 101, 100, 0, 0, 0, + 26, 0, 0, 0, 0, 0, 0, 0, + 12, 222, 128, 127, 0, 0, 0, 0, + 210, 4, 210, 233, 0, 128, 255, 127, + 78, 97, 188, 0, 64, 211, 160, 250, + 0, 0, 0, 128, 255, 255, 255, 127, + 121, 223, 13, 134, 72, 112, 0, 0, + 46, 117, 19, 253, 138, 150, 253, 255, + 0, 0, 0, 0, 0, 0, 0, 128, + 255, 255, 255, 255, 255, 255, 255, 127, + 12, 34, 0, 255, 0, 0, 0, 0, + 210, 4, 46, 22, 0, 0, 255, 255, + 78, 97, 188, 0, 192, 44, 95, 5, + 0, 0, 0, 0, 255, 255, 255, 255, + 121, 223, 13, 134, 72, 112, 0, 0, + 210, 138, 236, 2, 117, 105, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 255, 255, 255, 255, 255, 255, 255, 255, + 0, 0, 0, 0, 56, 180, 150, 73, + 194, 189, 240, 124, 194, 189, 240, 252, + 234, 28, 8, 2, 234, 28, 8, 130, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 222, 119, 131, 33, 18, 220, 66, + 41, 144, 35, 202, 229, 200, 118, 127, + 41, 144, 35, 202, 229, 200, 118, 255, + 145, 247, 80, 55, 158, 120, 102, 0, + 145, 247, 80, 55, 158, 120, 102, 128, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 58, 0, 0, 0, + 113, 117, 117, 120, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 9, 0, 0, 0, 50, 0, 0, 0, + 9, 0, 0, 0, 42, 0, 0, 0, + 9, 0, 0, 0, 34, 0, 0, 0, + 103, 97, 114, 112, 108, 121, 0, 0, + 119, 97, 108, 100, 111, 0, 0, 0, + 102, 114, 101, 100, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 122, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 49, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 50, 0, 0, + 120, 32, 115, 116, 114, 117, 99, 116, + 108, 105, 115, 116, 32, 51, 0, 0, + 3, 0, 1, 0, 6, 0, 0, 0, + 103, 43, 153, 212, 0, 0, 0, 0, + 12, 0, 0, 0, 6, 0, 20, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 1, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 189, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 93, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 49, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 50, 0, 0, 0, 0, + 115, 116, 114, 117, 99, 116, 108, 105, + 115, 116, 32, 51, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_a4764c3483341eeb = { + 0xa4764c3483341eeb, b_a4764c3483341eeb.words, 343, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<35> b_88eb12a0e0af92b2 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 250, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 127, 0, 0, 0, + 97, 0, 0, 0, 5, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 145, 179, 89, 213, 192, 237, 116, 184, + 164, 75, 113, 171, 221, 202, 79, 176, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 104, 37, 180, 87, 51, 137, 68, 208, + 47, 213, 71, 66, 223, 65, 241, 155, + 29, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 188, 207, 145, 42, 187, 138, 172, 217, + 45, 91, 55, 47, 79, 209, 153, 155, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 102, 111, 111, 0, 0, 0, 0, 0, + 98, 97, 114, 0, 0, 0, 0, 0, + 98, 97, 122, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_88eb12a0e0af92b2[] = { + &s_9b99d14f2f375b2d, + &s_9bf141df4247d52f, + &s_b04fcaddab714ba4, + &s_b874edc0d559b391, + &s_d044893357b42568, + &s_d9ac8abb2a91cfbc, +}; +static const uint16_t m_88eb12a0e0af92b2[] = {1, 2, 0}; +const ::capnp::_::RawSchema s_88eb12a0e0af92b2 = { + 0x88eb12a0e0af92b2, b_88eb12a0e0af92b2.words, 35, d_88eb12a0e0af92b2, m_88eb12a0e0af92b2, + 6, 3, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_b874edc0d559b391 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 145, 179, 89, 213, 192, 237, 116, 184, + 31, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 82, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 46, 102, + 111, 111, 36, 80, 97, 114, 97, 109, + 115, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 32, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 105, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 106, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_b874edc0d559b391[] = {0, 1}; +static const uint16_t i_b874edc0d559b391[] = {0, 1}; +const ::capnp::_::RawSchema s_b874edc0d559b391 = { + 0xb874edc0d559b391, b_b874edc0d559b391.words, 46, nullptr, m_b874edc0d559b391, + 0, 2, i_b874edc0d559b391, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_b04fcaddab714ba4 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 164, 75, 113, 171, 221, 202, 79, 176, + 31, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 46, 102, + 111, 111, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 120, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_b04fcaddab714ba4[] = {0}; +static const uint16_t i_b04fcaddab714ba4[] = {0}; +const ::capnp::_::RawSchema s_b04fcaddab714ba4 = { + 0xb04fcaddab714ba4, b_b04fcaddab714ba4.words, 32, nullptr, m_b04fcaddab714ba4, + 0, 1, i_b04fcaddab714ba4, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_d044893357b42568 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 104, 37, 180, 87, 51, 137, 68, 208, + 31, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 82, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 46, 98, + 97, 114, 36, 80, 97, 114, 97, 109, + 115, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_d044893357b42568 = { + 0xd044893357b42568, b_d044893357b42568.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_9bf141df4247d52f = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 47, 213, 71, 66, 223, 65, 241, 155, + 31, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 46, 98, + 97, 114, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_9bf141df4247d52f = { + 0x9bf141df4247d52f, b_9bf141df4247d52f.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_d9ac8abb2a91cfbc = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 188, 207, 145, 42, 187, 138, 172, 217, + 31, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 82, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 46, 98, + 97, 122, 36, 80, 97, 114, 97, 109, + 115, 0, 0, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 115, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_d9ac8abb2a91cfbc[] = { + &s_a0a8f314b80b63fd, +}; +static const uint16_t m_d9ac8abb2a91cfbc[] = {0}; +static const uint16_t i_d9ac8abb2a91cfbc[] = {0}; +const ::capnp::_::RawSchema s_d9ac8abb2a91cfbc = { + 0xd9ac8abb2a91cfbc, b_d9ac8abb2a91cfbc.words, 32, d_d9ac8abb2a91cfbc, m_d9ac8abb2a91cfbc, + 1, 1, i_d9ac8abb2a91cfbc, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_9b99d14f2f375b2d = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 45, 91, 55, 47, 79, 209, 153, 155, + 31, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 73, 110, 116, + 101, 114, 102, 97, 99, 101, 46, 98, + 97, 122, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_9b99d14f2f375b2d = { + 0x9b99d14f2f375b2d, b_9b99d14f2f375b2d.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<36> b_e4e9bac98670b748 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 72, 183, 112, 134, 201, 186, 233, 228, + 0, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 234, 0, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 127, 0, 0, 0, + 97, 0, 0, 0, 13, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 69, 120, 116, + 101, 110, 100, 115, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 3, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 23, 63, 54, 113, 84, 188, 164, 131, + 221, 83, 39, 62, 26, 61, 75, 142, + 45, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 253, 99, 11, 184, 20, 243, 168, 160, + 217, 186, 231, 167, 50, 117, 246, 172, + 29, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 246, 138, 234, 81, 232, 52, 184, 243, + 253, 99, 11, 184, 20, 243, 168, 160, + 13, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 113, 117, 120, 0, 0, 0, 0, 0, + 99, 111, 114, 103, 101, 0, 0, 0, + 103, 114, 97, 117, 108, 116, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, } +}; +static const ::capnp::_::RawSchema* const d_e4e9bac98670b748[] = { + &s_83a4bc5471363f17, + &s_88eb12a0e0af92b2, + &s_8e4b3d1a3e2753dd, + &s_a0a8f314b80b63fd, + &s_acf67532a7e7bad9, + &s_f3b834e851ea8af6, +}; +static const uint16_t m_e4e9bac98670b748[] = {1, 2, 0}; +const ::capnp::_::RawSchema s_e4e9bac98670b748 = { + 0xe4e9bac98670b748, b_e4e9bac98670b748.words, 36, d_e4e9bac98670b748, m_e4e9bac98670b748, + 6, 3, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<16> b_83a4bc5471363f17 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 23, 63, 54, 113, 84, 188, 164, 131, + 29, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 66, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 69, 120, 116, + 101, 110, 100, 115, 46, 113, 117, 120, + 36, 80, 97, 114, 97, 109, 115, 0, } +}; +const ::capnp::_::RawSchema s_83a4bc5471363f17 = { + 0x83a4bc5471363f17, b_83a4bc5471363f17.words, 16, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_8e4b3d1a3e2753dd = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 221, 83, 39, 62, 26, 61, 75, 142, + 29, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 74, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 69, 120, 116, + 101, 110, 100, 115, 46, 113, 117, 120, + 36, 82, 101, 115, 117, 108, 116, 115, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_8e4b3d1a3e2753dd = { + 0x8e4b3d1a3e2753dd, b_8e4b3d1a3e2753dd.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_acf67532a7e7bad9 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 217, 186, 231, 167, 50, 117, 246, 172, + 29, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 69, 120, 116, + 101, 110, 100, 115, 46, 99, 111, 114, + 103, 101, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_acf67532a7e7bad9 = { + 0xacf67532a7e7bad9, b_acf67532a7e7bad9.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_f3b834e851ea8af6 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 246, 138, 234, 81, 232, 52, 184, 243, + 29, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 69, 120, 116, + 101, 110, 100, 115, 46, 103, 114, 97, + 117, 108, 116, 36, 80, 97, 114, 97, + 109, 115, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_f3b834e851ea8af6 = { + 0xf3b834e851ea8af6, b_f3b834e851ea8af6.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<33> b_a5a404caa61d4cd0 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 208, 76, 29, 166, 202, 4, 164, 165, + 0, 0, 0, 0, 3, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 242, 0, 0, 0, + 29, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 87, 0, 0, 0, + 89, 0, 0, 0, 5, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 80, 105, 112, + 101, 108, 105, 110, 101, 0, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 177, 38, 14, 219, 81, 158, 178, 176, + 1, 0, 0, 0, 34, 0, 0, 0, + 66, 111, 120, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 52, 112, 37, 150, 80, 223, 232, 199, + 223, 143, 162, 11, 158, 42, 68, 178, + 25, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 159, 129, 55, 207, 99, 238, 4, 166, + 214, 112, 96, 108, 117, 84, 218, 142, + 9, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 103, 101, 116, 67, 97, 112, 0, 0, + 116, 101, 115, 116, 80, 111, 105, 110, + 116, 101, 114, 115, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_a5a404caa61d4cd0[] = { + &s_8eda54756c6070d6, + &s_a604ee63cf37819f, + &s_b2442a9e0ba28fdf, + &s_c7e8df5096257034, +}; +static const uint16_t m_a5a404caa61d4cd0[] = {0, 1}; +const ::capnp::_::RawSchema s_a5a404caa61d4cd0 = { + 0xa5a404caa61d4cd0, b_a5a404caa61d4cd0.words, 33, d_a5a404caa61d4cd0, m_a5a404caa61d4cd0, + 4, 2, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_b0b29e51db0e26b1 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 177, 38, 14, 219, 81, 158, 178, 176, + 0, 0, 0, 0, 1, 0, 0, 0, + 208, 76, 29, 166, 202, 4, 164, 165, + 1, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 18, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 80, 105, 112, + 101, 108, 105, 110, 101, 46, 66, 111, + 120, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_b0b29e51db0e26b1[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_b0b29e51db0e26b1[] = {0}; +static const uint16_t i_b0b29e51db0e26b1[] = {0}; +const ::capnp::_::RawSchema s_b0b29e51db0e26b1 = { + 0xb0b29e51db0e26b1, b_b0b29e51db0e26b1.words, 32, d_b0b29e51db0e26b1, m_b0b29e51db0e26b1, + 1, 1, i_b0b29e51db0e26b1, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_c7e8df5096257034 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 52, 112, 37, 150, 80, 223, 232, 199, + 30, 0, 0, 0, 1, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 98, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 80, 105, 112, + 101, 108, 105, 110, 101, 46, 103, 101, + 116, 67, 97, 112, 36, 80, 97, 114, + 97, 109, 115, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 50, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 110, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 105, 110, 67, 97, 112, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_c7e8df5096257034[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_c7e8df5096257034[] = {1, 0}; +static const uint16_t i_c7e8df5096257034[] = {0, 1}; +const ::capnp::_::RawSchema s_c7e8df5096257034 = { + 0xc7e8df5096257034, b_c7e8df5096257034.words, 46, d_c7e8df5096257034, m_c7e8df5096257034, + 1, 2, i_c7e8df5096257034, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<46> b_b2442a9e0ba28fdf = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 223, 143, 162, 11, 158, 42, 68, 178, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 106, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 119, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 80, 105, 112, + 101, 108, 105, 110, 101, 46, 103, 101, + 116, 67, 97, 112, 36, 82, 101, 115, + 117, 108, 116, 115, 0, 0, 0, 0, + 8, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 18, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 58, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 36, 0, 0, 0, 2, 0, 1, 0, + 44, 0, 0, 0, 2, 0, 1, 0, + 115, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 117, 116, 66, 111, 120, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 177, 38, 14, 219, 81, 158, 178, 176, + 0, 0, 0, 0, 0, 0, 0, 0, + 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_b2442a9e0ba28fdf[] = { + &s_b0b29e51db0e26b1, +}; +static const uint16_t m_b2442a9e0ba28fdf[] = {1, 0}; +static const uint16_t i_b2442a9e0ba28fdf[] = {0, 1}; +const ::capnp::_::RawSchema s_b2442a9e0ba28fdf = { + 0xb2442a9e0ba28fdf, b_b2442a9e0ba28fdf.words, 46, d_b2442a9e0ba28fdf, m_b2442a9e0ba28fdf, + 1, 2, i_b2442a9e0ba28fdf, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<64> b_a604ee63cf37819f = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 159, 129, 55, 207, 99, 238, 4, 166, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 7, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 146, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 175, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 80, 105, 112, + 101, 108, 105, 110, 101, 46, 116, 101, + 115, 116, 80, 111, 105, 110, 116, 101, + 114, 115, 36, 80, 97, 114, 97, 109, + 115, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 1, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 72, 0, 0, 0, 2, 0, 1, 0, + 2, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 1, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 69, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 64, 0, 0, 0, 2, 0, 1, 0, + 84, 0, 0, 0, 2, 0, 1, 0, + 99, 97, 112, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 111, 98, 106, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 108, 105, 115, 116, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 1, 0, + 17, 0, 0, 0, 0, 0, 0, 0, + 178, 146, 175, 224, 160, 18, 235, 136, + 0, 0, 0, 0, 0, 0, 0, 0, + 14, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_a604ee63cf37819f[] = { + &s_88eb12a0e0af92b2, +}; +static const uint16_t m_a604ee63cf37819f[] = {0, 2, 1}; +static const uint16_t i_a604ee63cf37819f[] = {0, 1, 2}; +const ::capnp::_::RawSchema s_a604ee63cf37819f = { + 0xa604ee63cf37819f, b_a604ee63cf37819f.words, 64, d_a604ee63cf37819f, m_a604ee63cf37819f, + 1, 3, i_a604ee63cf37819f, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<18> b_8eda54756c6070d6 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 214, 112, 96, 108, 117, 84, 218, 142, + 30, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 154, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 80, 105, 112, + 101, 108, 105, 110, 101, 46, 116, 101, + 115, 116, 80, 111, 105, 110, 116, 101, + 114, 115, 36, 82, 101, 115, 117, 108, + 116, 115, 0, 0, 0, 0, 0, 0, } +}; +const ::capnp::_::RawSchema s_8eda54756c6070d6 = { + 0x8eda54756c6070d6, b_8eda54756c6070d6.words, 18, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<32> b_e02d3bbe1010e342 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 66, 227, 16, 16, 190, 59, 45, 224, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 1, 0, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 42, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 83, 116, 117, + 114, 100, 121, 82, 101, 102, 72, 111, + 115, 116, 73, 100, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 42, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 104, 111, 115, 116, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const uint16_t m_e02d3bbe1010e342[] = {0}; +static const uint16_t i_e02d3bbe1010e342[] = {0}; +const ::capnp::_::RawSchema s_e02d3bbe1010e342 = { + 0xe02d3bbe1010e342, b_e02d3bbe1010e342.words, 32, nullptr, m_e02d3bbe1010e342, + 0, 1, i_e02d3bbe1010e342, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<35> b_aeb2ad168e2f5697 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 151, 86, 47, 142, 22, 173, 178, 174, + 0, 0, 0, 0, 1, 0, 1, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 58, 1, 0, 0, + 33, 0, 0, 0, 23, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 41, 0, 0, 0, 63, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 83, 116, 117, + 114, 100, 121, 82, 101, 102, 79, 98, + 106, 101, 99, 116, 73, 100, 0, 0, + 4, 0, 0, 0, 1, 0, 1, 0, + 57, 212, 196, 103, 47, 143, 66, 239, + 1, 0, 0, 0, 34, 0, 0, 0, + 84, 97, 103, 0, 0, 0, 0, 0, + 4, 0, 0, 0, 3, 0, 4, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 13, 0, 0, 0, 34, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 8, 0, 0, 0, 2, 0, 1, 0, + 16, 0, 0, 0, 2, 0, 1, 0, + 116, 97, 103, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 57, 212, 196, 103, 47, 143, 66, 239, + 0, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, } +}; +static const ::capnp::_::RawSchema* const d_aeb2ad168e2f5697[] = { + &s_ef428f2f67c4d439, +}; +static const uint16_t m_aeb2ad168e2f5697[] = {0}; +static const uint16_t i_aeb2ad168e2f5697[] = {0}; +const ::capnp::_::RawSchema s_aeb2ad168e2f5697 = { + 0xaeb2ad168e2f5697, b_aeb2ad168e2f5697.words, 35, d_aeb2ad168e2f5697, m_aeb2ad168e2f5697, + 1, 1, i_aeb2ad168e2f5697, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<34> b_ef428f2f67c4d439 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 57, 212, 196, 103, 47, 143, 66, 239, + 0, 0, 0, 0, 2, 0, 0, 0, + 151, 86, 47, 142, 22, 173, 178, 174, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 90, 1, 0, 0, + 37, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 33, 0, 0, 0, 79, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 83, 116, 117, + 114, 100, 121, 82, 101, 102, 79, 98, + 106, 101, 99, 116, 73, 100, 46, 84, + 97, 103, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, + 12, 0, 0, 0, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 29, 0, 0, 0, 114, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 98, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 2, 0, 0, 0, 0, 0, 0, 0, + 21, 0, 0, 0, 106, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 73, 110, 116, 101, + 114, 102, 97, 99, 101, 0, 0, 0, + 116, 101, 115, 116, 69, 120, 116, 101, + 110, 100, 115, 0, 0, 0, 0, 0, + 116, 101, 115, 116, 80, 105, 112, 101, + 108, 105, 110, 101, 0, 0, 0, 0, } +}; +static const uint16_t m_ef428f2f67c4d439[] = {1, 0, 2}; +const ::capnp::_::RawSchema s_ef428f2f67c4d439 = { + 0xef428f2f67c4d439, b_ef428f2f67c4d439.words, 34, nullptr, m_ef428f2f67c4d439, + 0, 3, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_9e5c574772b1d462 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 98, 212, 177, 114, 71, 87, 92, 158, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 10, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 80, 114, 111, + 118, 105, 115, 105, 111, 110, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +const ::capnp::_::RawSchema s_9e5c574772b1d462 = { + 0x9e5c574772b1d462, b_9e5c574772b1d462.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_ea2fb7dca9cdbdea = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 234, 189, 205, 169, 220, 183, 47, 234, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 10, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 82, 101, 99, + 105, 112, 105, 101, 110, 116, 73, 100, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +const ::capnp::_::RawSchema s_ea2fb7dca9cdbdea = { + 0xea2fb7dca9cdbdea, b_ea2fb7dca9cdbdea.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<17> b_a805157b98b65469 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 105, 84, 182, 152, 123, 21, 5, 168, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 42, 1, 0, 0, + 33, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 84, 104, 105, + 114, 100, 80, 97, 114, 116, 121, 67, + 97, 112, 73, 100, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +const ::capnp::_::RawSchema s_a805157b98b65469 = { + 0xa805157b98b65469, b_a805157b98b65469.words, 17, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +static const ::capnp::_::AlignedData<16> b_b589fd166c4f1f54 = { + { 0, 0, 0, 0, 5, 0, 5, 0, + 84, 31, 79, 108, 22, 253, 137, 181, + 0, 0, 0, 0, 1, 0, 0, 0, + 184, 66, 220, 194, 189, 238, 8, 213, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 17, 0, 0, 0, 2, 1, 0, 0, + 29, 0, 0, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 99, 97, 112, 110, 112, 47, 116, 101, + 115, 116, 46, 99, 97, 112, 110, 112, + 58, 84, 101, 115, 116, 74, 111, 105, + 110, 65, 110, 115, 119, 101, 114, 0, + 0, 0, 0, 0, 1, 0, 1, 0, } +}; +const ::capnp::_::RawSchema s_b589fd166c4f1f54 = { + 0xb589fd166c4f1f54, b_b589fd166c4f1f54.words, 16, nullptr, nullptr, + 0, 0, nullptr, nullptr, nullptr +}; +} // namespace schemas +namespace _ { // private +CAPNP_DEFINE_ENUM( + ::capnproto_test::capnp::test::TestEnum); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestAllTypes); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestDefaults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestObject); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestOutOfOrder); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnion::Union0); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnion::Union1); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnion::Union2); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnion::Union3); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnnamedUnion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnionInUnion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnionInUnion::Outer); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnionInUnion::Outer::Inner); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestGroups); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestGroups::Groups); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestGroups::Groups::Foo); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestGroups::Groups::Baz); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestGroups::Groups::Bar); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups::Group1); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups::Group1::Corge); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups::Group2); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups::Group2::Corge); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUnionDefaults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestNestedTypes); +CAPNP_DEFINE_ENUM( + ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct); +CAPNP_DEFINE_ENUM( + ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestUsing); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct0); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct1); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct8); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct16); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct32); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct64); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::StructP); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct0c); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct1c); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct8c); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct16c); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct32c); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct64c); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLists::StructPc); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestFieldZeroIsBit); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestListDefaults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLateUnion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLateUnion::TheUnion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestLateUnion::AnotherUnion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestOldVersion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestNewVersion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestStructUnion); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestStructUnion::Un); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestEmptyStruct); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestConstants); +CAPNP_DEFINE_INTERFACE( + ::capnproto_test::capnp::test::TestInterface); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::FooParams); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::FooResults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::BarParams); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::BarResults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::BazParams); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::BazResults); +CAPNP_DEFINE_INTERFACE( + ::capnproto_test::capnp::test::TestExtends); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestExtends::QuxParams); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestExtends::QuxResults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestExtends::CorgeResults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestExtends::GraultParams); +CAPNP_DEFINE_INTERFACE( + ::capnproto_test::capnp::test::TestPipeline); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::Box); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::GetCapParams); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::GetCapResults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::TestPointersParams); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::TestPointersResults); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestSturdyRefHostId); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestSturdyRefObjectId); +CAPNP_DEFINE_ENUM( + ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestProvisionId); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestRecipientId); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestThirdPartyCapId); +CAPNP_DEFINE_STRUCT( + ::capnproto_test::capnp::test::TestJoinAnswer); +} // namespace _ (private) +} // namespace capnp + +// ======================================================================================= + +namespace capnproto_test { +namespace capnp { +namespace test { + +constexpr ::capnp::Void TestConstants::VOID_CONST; +constexpr bool TestConstants::BOOL_CONST; +constexpr ::int8_t TestConstants::INT8_CONST; +constexpr ::int16_t TestConstants::INT16_CONST; +constexpr ::int32_t TestConstants::INT32_CONST; +constexpr ::int64_t TestConstants::INT64_CONST; +constexpr ::uint8_t TestConstants::UINT8_CONST; +constexpr ::uint16_t TestConstants::UINT16_CONST; +constexpr ::uint32_t TestConstants::UINT32_CONST; +constexpr ::uint64_t TestConstants::UINT64_CONST; +constexpr float TestConstants::FLOAT32_CONST; +constexpr double TestConstants::FLOAT64_CONST; +const ::capnp::_::ConstText<3> TestConstants::TEXT_CONST(::capnp::schemas::b_f346e8becc34c826.words + 24); +const ::capnp::_::ConstData<3> TestConstants::DATA_CONST(::capnp::schemas::b_aaa4fc67c55b78fd.words + 24); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> TestConstants::STRUCT_CONST(::capnp::schemas::b_ed37d4414bf1157a.words + 23); +constexpr ::capnproto_test::capnp::test::TestEnum TestConstants::ENUM_CONST; +const ::capnp::_::ConstList< ::capnp::Void> TestConstants::VOID_LIST_CONST(::capnp::schemas::b_e3201c2e657cf0fc.words + 26); +const ::capnp::_::ConstList TestConstants::BOOL_LIST_CONST(::capnp::schemas::b_ce1810c84e108cdc.words + 26); +const ::capnp::_::ConstList< ::int8_t> TestConstants::INT8_LIST_CONST(::capnp::schemas::b_ff58bf5895b73ee2.words + 26); +const ::capnp::_::ConstList< ::int16_t> TestConstants::INT16_LIST_CONST(::capnp::schemas::b_a145449a15848a09.words + 26); +const ::capnp::_::ConstList< ::int32_t> TestConstants::INT32_LIST_CONST(::capnp::schemas::b_a567a743b6b4bf0d.words + 26); +const ::capnp::_::ConstList< ::int64_t> TestConstants::INT64_LIST_CONST(::capnp::schemas::b_d987eb8af5945021.words + 26); +const ::capnp::_::ConstList< ::uint8_t> TestConstants::UINT8_LIST_CONST(::capnp::schemas::b_9e55f87eb2ffa805.words + 26); +const ::capnp::_::ConstList< ::uint16_t> TestConstants::UINT16_LIST_CONST(::capnp::schemas::b_fe4d1147d7537f4c.words + 26); +const ::capnp::_::ConstList< ::uint32_t> TestConstants::UINT32_LIST_CONST(::capnp::schemas::b_900218d4541375d3.words + 26); +const ::capnp::_::ConstList< ::uint64_t> TestConstants::UINT64_LIST_CONST(::capnp::schemas::b_d26dd7a486f26cd7.words + 26); +const ::capnp::_::ConstList TestConstants::FLOAT32_LIST_CONST(::capnp::schemas::b_feb875138580a065.words + 26); +const ::capnp::_::ConstList TestConstants::FLOAT64_LIST_CONST(::capnp::schemas::b_a815a514acbab212.words + 26); +const ::capnp::_::ConstList< ::capnp::Text> TestConstants::TEXT_LIST_CONST(::capnp::schemas::b_ec56db537c838603.words + 26); +const ::capnp::_::ConstList< ::capnp::Data> TestConstants::DATA_LIST_CONST(::capnp::schemas::b_c468785db6321458.words + 26); +const ::capnp::_::ConstList< ::capnproto_test::capnp::test::TestAllTypes> TestConstants::STRUCT_LIST_CONST(::capnp::schemas::b_d1f994d3d4fbbaed.words + 26); +const ::capnp::_::ConstList< ::capnproto_test::capnp::test::TestEnum> TestConstants::ENUM_LIST_CONST(::capnp::schemas::b_c30860d747fd5019.words + 26); +const ::capnp::_::ConstText<6> GLOBAL_TEXT(::capnp::schemas::b_d81b65e268fb3f34.words + 22); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> GLOBAL_STRUCT(::capnp::schemas::b_bd579b448bfbcc7b.words + 21); +const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> DERIVED_CONSTANT(::capnp::schemas::b_a4764c3483341eeb.words + 22); +::capnp::Request +TestInterface::Client::fooRequest(unsigned int firstSegmentWordSize) const { + return newCall( + 0x88eb12a0e0af92b2ull, 0, firstSegmentWordSize); +} +::kj::Promise TestInterface::Server::foo( + TestInterface::FooParams::Reader, TestInterface::FooResults::Builder) { + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestInterface", "foo", + 0x88eb12a0e0af92b2ull, 0); +} +::kj::Promise TestInterface::Server::fooAdvanced( + ::capnp::CallContext context) { + return foo(context.getParams(), context.getResults()); +} +::capnp::Request +TestInterface::Client::barRequest(unsigned int firstSegmentWordSize) const { + return newCall( + 0x88eb12a0e0af92b2ull, 1, firstSegmentWordSize); +} +::kj::Promise TestInterface::Server::bar( + TestInterface::BarParams::Reader, TestInterface::BarResults::Builder) { + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestInterface", "bar", + 0x88eb12a0e0af92b2ull, 1); +} +::kj::Promise TestInterface::Server::barAdvanced( + ::capnp::CallContext context) { + return bar(context.getParams(), context.getResults()); +} +::capnp::Request +TestInterface::Client::bazRequest(unsigned int firstSegmentWordSize) const { + return newCall( + 0x88eb12a0e0af92b2ull, 2, firstSegmentWordSize); +} +::kj::Promise TestInterface::Server::baz( + TestInterface::BazParams::Reader, TestInterface::BazResults::Builder) { + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestInterface", "baz", + 0x88eb12a0e0af92b2ull, 2); +} +::kj::Promise TestInterface::Server::bazAdvanced( + ::capnp::CallContext context) { + return baz(context.getParams(), context.getResults()); +} +::kj::Promise TestInterface::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) { + switch (interfaceId) { + case 0x88eb12a0e0af92b2ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("capnp/test.capnp:TestInterface", interfaceId); + } +} +::kj::Promise TestInterface::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) { + switch (methodId) { + case 0: + return fooAdvanced(::capnp::Capability::Server::internalGetTypedContext< + TestInterface::FooParams, TestInterface::FooResults>(context)); + case 1: + return barAdvanced(::capnp::Capability::Server::internalGetTypedContext< + TestInterface::BarParams, TestInterface::BarResults>(context)); + case 2: + return bazAdvanced(::capnp::Capability::Server::internalGetTypedContext< + TestInterface::BazParams, TestInterface::BazResults>(context)); + default: + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestInterface", + 0x88eb12a0e0af92b2ull, methodId); + } +} +::capnp::Request +TestExtends::Client::quxRequest(unsigned int firstSegmentWordSize) const { + return newCall( + 0xe4e9bac98670b748ull, 0, firstSegmentWordSize); +} +::kj::Promise TestExtends::Server::qux( + TestExtends::QuxParams::Reader, TestExtends::QuxResults::Builder) { + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestExtends", "qux", + 0xe4e9bac98670b748ull, 0); +} +::kj::Promise TestExtends::Server::quxAdvanced( + ::capnp::CallContext context) { + return qux(context.getParams(), context.getResults()); +} +::capnp::Request< ::capnproto_test::capnp::test::TestAllTypes, TestExtends::CorgeResults> +TestExtends::Client::corgeRequest(unsigned int firstSegmentWordSize) const { + return newCall< ::capnproto_test::capnp::test::TestAllTypes, TestExtends::CorgeResults>( + 0xe4e9bac98670b748ull, 1, firstSegmentWordSize); +} +::kj::Promise TestExtends::Server::corge( + ::capnproto_test::capnp::test::TestAllTypes::Reader, TestExtends::CorgeResults::Builder) { + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestExtends", "corge", + 0xe4e9bac98670b748ull, 1); +} +::kj::Promise TestExtends::Server::corgeAdvanced( + ::capnp::CallContext< ::capnproto_test::capnp::test::TestAllTypes, TestExtends::CorgeResults> context) { + return corge(context.getParams(), context.getResults()); +} +::capnp::Request +TestExtends::Client::graultRequest(unsigned int firstSegmentWordSize) const { + return newCall( + 0xe4e9bac98670b748ull, 2, firstSegmentWordSize); +} +::kj::Promise TestExtends::Server::grault( + TestExtends::GraultParams::Reader, ::capnproto_test::capnp::test::TestAllTypes::Builder) { + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestExtends", "grault", + 0xe4e9bac98670b748ull, 2); +} +::kj::Promise TestExtends::Server::graultAdvanced( + ::capnp::CallContext context) { + return grault(context.getParams(), context.getResults()); +} +::kj::Promise TestExtends::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) { + switch (interfaceId) { + case 0xe4e9bac98670b748ull: + return dispatchCallInternal(methodId, context); + case 0x88eb12a0e0af92b2ull: + return ::capnproto_test::capnp::test::TestInterface::Server::dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("capnp/test.capnp:TestExtends", interfaceId); + } +} +::kj::Promise TestExtends::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) { + switch (methodId) { + case 0: + return quxAdvanced(::capnp::Capability::Server::internalGetTypedContext< + TestExtends::QuxParams, TestExtends::QuxResults>(context)); + case 1: + return corgeAdvanced(::capnp::Capability::Server::internalGetTypedContext< + ::capnproto_test::capnp::test::TestAllTypes, TestExtends::CorgeResults>(context)); + case 2: + return graultAdvanced(::capnp::Capability::Server::internalGetTypedContext< + TestExtends::GraultParams, ::capnproto_test::capnp::test::TestAllTypes>(context)); + default: + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestExtends", + 0xe4e9bac98670b748ull, methodId); + } +} +::capnp::Request +TestPipeline::Client::getCapRequest(unsigned int firstSegmentWordSize) const { + return newCall( + 0xa5a404caa61d4cd0ull, 0, firstSegmentWordSize); +} +::kj::Promise TestPipeline::Server::getCap( + TestPipeline::GetCapParams::Reader, TestPipeline::GetCapResults::Builder) { + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestPipeline", "getCap", + 0xa5a404caa61d4cd0ull, 0); +} +::kj::Promise TestPipeline::Server::getCapAdvanced( + ::capnp::CallContext context) { + return getCap(context.getParams(), context.getResults()); +} +::capnp::Request +TestPipeline::Client::testPointersRequest(unsigned int firstSegmentWordSize) const { + return newCall( + 0xa5a404caa61d4cd0ull, 1, firstSegmentWordSize); +} +::kj::Promise TestPipeline::Server::testPointers( + TestPipeline::TestPointersParams::Reader, TestPipeline::TestPointersResults::Builder) { + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestPipeline", "testPointers", + 0xa5a404caa61d4cd0ull, 1); +} +::kj::Promise TestPipeline::Server::testPointersAdvanced( + ::capnp::CallContext context) { + return testPointers(context.getParams(), context.getResults()); +} +::kj::Promise TestPipeline::Server::dispatchCall( + uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) { + switch (interfaceId) { + case 0xa5a404caa61d4cd0ull: + return dispatchCallInternal(methodId, context); + default: + return internalUnimplemented("capnp/test.capnp:TestPipeline", interfaceId); + } +} +::kj::Promise TestPipeline::Server::dispatchCallInternal( + uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) { + switch (methodId) { + case 0: + return getCapAdvanced(::capnp::Capability::Server::internalGetTypedContext< + TestPipeline::GetCapParams, TestPipeline::GetCapResults>(context)); + case 1: + return testPointersAdvanced(::capnp::Capability::Server::internalGetTypedContext< + TestPipeline::TestPointersParams, TestPipeline::TestPointersResults>(context)); + default: + return ::capnp::Capability::Server::internalUnimplemented( + "capnp/test.capnp:TestPipeline", + 0xa5a404caa61d4cd0ull, methodId); + } +} + +} // namespace +} // namespace +} // namespace + diff --git a/examples/test.capnp.h b/examples/test.capnp.h new file mode 100644 index 0000000..b123115 --- /dev/null +++ b/examples/test.capnp.h @@ -0,0 +1,16936 @@ +// Generated by Cap'n Proto compiler, DO NOT EDIT +// source: test.capnp + +#ifndef CAPNP_INCLUDED_d508eebdc2dc42b8_ +#define CAPNP_INCLUDED_d508eebdc2dc42b8_ + +#include +#include + +#if CAPNP_VERSION != 4000 +#error "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." +#endif + + +namespace capnproto_test { +namespace capnp { +namespace test { + +enum class TestEnum: uint16_t { + FOO, + BAR, + BAZ, + QUX, + QUUX, + CORGE, + GRAULT, + GARPLY, +}; + +struct TestAllTypes { + TestAllTypes() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestDefaults { + TestDefaults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestObject { + TestObject() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestOutOfOrder { + TestOutOfOrder() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestUnion { + TestUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Union0; + struct Union1; + struct Union2; + struct Union3; +}; + +struct TestUnion::Union0 { + Union0() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + U0F0S0, + U0F0S1, + U0F0S8, + U0F0S16, + U0F0S32, + U0F0S64, + U0F0SP, + U0F1S0, + U0F1S1, + U0F1S8, + U0F1S16, + U0F1S32, + U0F1S64, + U0F1SP, + }; +}; + +struct TestUnion::Union1 { + Union1() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + U1F0S0, + U1F0S1, + U1F1S1, + U1F0S8, + U1F1S8, + U1F0S16, + U1F1S16, + U1F0S32, + U1F1S32, + U1F0S64, + U1F1S64, + U1F0SP, + U1F1SP, + U1F2S0, + U1F2S1, + U1F2S8, + U1F2S16, + U1F2S32, + U1F2S64, + U1F2SP, + }; +}; + +struct TestUnion::Union2 { + Union2() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + U2F0S1, + U2F0S8, + U2F0S16, + U2F0S32, + U2F0S64, + }; +}; + +struct TestUnion::Union3 { + Union3() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + U3F0S1, + U3F0S8, + U3F0S16, + U3F0S32, + U3F0S64, + }; +}; + +struct TestUnnamedUnion { + TestUnnamedUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + FOO, + BAR, + }; +}; + +struct TestUnionInUnion { + TestUnionInUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Outer; +}; + +struct TestUnionInUnion::Outer { + Outer() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + INNER, + BAZ, + }; + struct Inner; +}; + +struct TestUnionInUnion::Outer::Inner { + Inner() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + FOO, + BAR, + }; +}; + +struct TestGroups { + TestGroups() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Groups; +}; + +struct TestGroups::Groups { + Groups() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + FOO, + BAZ, + BAR, + }; + struct Foo; + struct Baz; + struct Bar; +}; + +struct TestGroups::Groups::Foo { + Foo() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestGroups::Groups::Baz { + Baz() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestGroups::Groups::Bar { + Bar() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestInterleavedGroups { + TestInterleavedGroups() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Group1; + struct Group2; +}; + +struct TestInterleavedGroups::Group1 { + Group1() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + QUX, + CORGE, + FRED, + }; + struct Corge; +}; + +struct TestInterleavedGroups::Group1::Corge { + Corge() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestInterleavedGroups::Group2 { + Group2() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + QUX, + CORGE, + FRED, + }; + struct Corge; +}; + +struct TestInterleavedGroups::Group2::Corge { + Corge() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestUnionDefaults { + TestUnionDefaults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestNestedTypes { + TestNestedTypes() = delete; + + class Reader; + class Builder; + class Pipeline; + enum class NestedEnum: uint16_t { + FOO, + BAR, + }; + + struct NestedStruct; +}; + +struct TestNestedTypes::NestedStruct { + NestedStruct() = delete; + + class Reader; + class Builder; + class Pipeline; + enum class NestedEnum: uint16_t { + BAZ, + QUX, + QUUX, + }; + +}; + +struct TestUsing { + TestUsing() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists { + TestLists() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Struct0; + struct Struct1; + struct Struct8; + struct Struct16; + struct Struct32; + struct Struct64; + struct StructP; + struct Struct0c; + struct Struct1c; + struct Struct8c; + struct Struct16c; + struct Struct32c; + struct Struct64c; + struct StructPc; +}; + +struct TestLists::Struct0 { + Struct0() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct1 { + Struct1() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct8 { + Struct8() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct16 { + Struct16() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct32 { + Struct32() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct64 { + Struct64() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::StructP { + StructP() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct0c { + Struct0c() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct1c { + Struct1c() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct8c { + Struct8c() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct16c { + Struct16c() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct32c { + Struct32c() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::Struct64c { + Struct64c() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLists::StructPc { + StructPc() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestFieldZeroIsBit { + TestFieldZeroIsBit() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestListDefaults { + TestListDefaults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestLateUnion { + TestLateUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + struct TheUnion; + struct AnotherUnion; +}; + +struct TestLateUnion::TheUnion { + TheUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + QUX, + CORGE, + GRAULT, + }; +}; + +struct TestLateUnion::AnotherUnion { + AnotherUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + QUX, + CORGE, + GRAULT, + }; +}; + +struct TestOldVersion { + TestOldVersion() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestNewVersion { + TestNewVersion() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestStructUnion { + TestStructUnion() = delete; + + class Reader; + class Builder; + class Pipeline; + struct Un; +}; + +struct TestStructUnion::Un { + Un() = delete; + + class Reader; + class Builder; + class Pipeline; + enum Which: uint16_t { + ALL_TYPES, + OBJECT, + }; +}; + +struct TestEmptyStruct { + TestEmptyStruct() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestConstants { + TestConstants() = delete; + + class Reader; + class Builder; + class Pipeline; + static constexpr ::capnp::Void VOID_CONST = ::capnp::VOID; + static constexpr bool BOOL_CONST = true; + static constexpr ::int8_t INT8_CONST = -123; + static constexpr ::int16_t INT16_CONST = -12345; + static constexpr ::int32_t INT32_CONST = -12345678; + static constexpr ::int64_t INT64_CONST = -123456789012345ll; + static constexpr ::uint8_t UINT8_CONST = 234u; + static constexpr ::uint16_t UINT16_CONST = 45678u; + static constexpr ::uint32_t UINT32_CONST = 3456789012u; + static constexpr ::uint64_t UINT64_CONST = 12345678901234567890llu; + static constexpr float FLOAT32_CONST = 1234.5f; + static constexpr double FLOAT64_CONST = -1.23e47; + static const ::capnp::_::ConstText<3> TEXT_CONST; + static const ::capnp::_::ConstData<3> DATA_CONST; + static const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> STRUCT_CONST; + static constexpr ::capnproto_test::capnp::test::TestEnum ENUM_CONST = ::capnproto_test::capnp::test::TestEnum::CORGE; + static const ::capnp::_::ConstList< ::capnp::Void> VOID_LIST_CONST; + static const ::capnp::_::ConstList BOOL_LIST_CONST; + static const ::capnp::_::ConstList< ::int8_t> INT8_LIST_CONST; + static const ::capnp::_::ConstList< ::int16_t> INT16_LIST_CONST; + static const ::capnp::_::ConstList< ::int32_t> INT32_LIST_CONST; + static const ::capnp::_::ConstList< ::int64_t> INT64_LIST_CONST; + static const ::capnp::_::ConstList< ::uint8_t> UINT8_LIST_CONST; + static const ::capnp::_::ConstList< ::uint16_t> UINT16_LIST_CONST; + static const ::capnp::_::ConstList< ::uint32_t> UINT32_LIST_CONST; + static const ::capnp::_::ConstList< ::uint64_t> UINT64_LIST_CONST; + static const ::capnp::_::ConstList FLOAT32_LIST_CONST; + static const ::capnp::_::ConstList FLOAT64_LIST_CONST; + static const ::capnp::_::ConstList< ::capnp::Text> TEXT_LIST_CONST; + static const ::capnp::_::ConstList< ::capnp::Data> DATA_LIST_CONST; + static const ::capnp::_::ConstList< ::capnproto_test::capnp::test::TestAllTypes> STRUCT_LIST_CONST; + static const ::capnp::_::ConstList< ::capnproto_test::capnp::test::TestEnum> ENUM_LIST_CONST; +}; + +static constexpr ::uint32_t GLOBAL_INT = 12345u; +extern const ::capnp::_::ConstText<6> GLOBAL_TEXT; +extern const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> GLOBAL_STRUCT; +extern const ::capnp::_::ConstStruct< ::capnproto_test::capnp::test::TestAllTypes> DERIVED_CONSTANT; +struct TestInterface { + TestInterface() = delete; + + class Client; + class Server; + + struct FooParams; + struct FooResults; + struct BarParams; + struct BarResults; + struct BazParams; + struct BazResults; +}; + +struct TestInterface::FooParams { + FooParams() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestInterface::FooResults { + FooResults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestInterface::BarParams { + BarParams() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestInterface::BarResults { + BarResults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestInterface::BazParams { + BazParams() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestInterface::BazResults { + BazResults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestExtends { + TestExtends() = delete; + + class Client; + class Server; + + struct QuxParams; + struct QuxResults; + struct CorgeResults; + struct GraultParams; +}; + +struct TestExtends::QuxParams { + QuxParams() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestExtends::QuxResults { + QuxResults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestExtends::CorgeResults { + CorgeResults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestExtends::GraultParams { + GraultParams() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestPipeline { + TestPipeline() = delete; + + class Client; + class Server; + + struct Box; + struct GetCapParams; + struct GetCapResults; + struct TestPointersParams; + struct TestPointersResults; +}; + +struct TestPipeline::Box { + Box() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestPipeline::GetCapParams { + GetCapParams() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestPipeline::GetCapResults { + GetCapResults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestPipeline::TestPointersParams { + TestPointersParams() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestPipeline::TestPointersResults { + TestPointersResults() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestSturdyRefHostId { + TestSturdyRefHostId() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestSturdyRefObjectId { + TestSturdyRefObjectId() = delete; + + class Reader; + class Builder; + class Pipeline; + enum class Tag: uint16_t { + TEST_INTERFACE, + TEST_EXTENDS, + TEST_PIPELINE, + }; + +}; + +struct TestProvisionId { + TestProvisionId() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestRecipientId { + TestRecipientId() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestThirdPartyCapId { + TestThirdPartyCapId() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +struct TestJoinAnswer { + TestJoinAnswer() = delete; + + class Reader; + class Builder; + class Pipeline; +}; + +} // namespace +} // namespace +} // namespace + +// ======================================================================================= + +namespace capnp { +namespace schemas { + +extern const ::capnp::_::RawSchema s_9c8e9318b29d9cd3; +extern const ::capnp::_::RawSchema s_a0a8f314b80b63fd; +extern const ::capnp::_::RawSchema s_eb3f9ebe98c73cb6; +extern const ::capnp::_::RawSchema s_d1f4434616a112ca; +extern const ::capnp::_::RawSchema s_a9d5f8efe770022b; +extern const ::capnp::_::RawSchema s_f47697362233ce52; +extern const ::capnp::_::RawSchema s_fc76a82eecb7a718; +extern const ::capnp::_::RawSchema s_ee0a6b99b7dc7ab2; +extern const ::capnp::_::RawSchema s_afc5fd419f0d66d4; +extern const ::capnp::_::RawSchema s_a2fb022ec7f30053; +extern const ::capnp::_::RawSchema s_9e2e784c915329b6; +extern const ::capnp::_::RawSchema s_89a9494f1b900f22; +extern const ::capnp::_::RawSchema s_d005f6c63707670c; +extern const ::capnp::_::RawSchema s_ff9ce111c6f8e5db; +extern const ::capnp::_::RawSchema s_dc841556134c3103; +extern const ::capnp::_::RawSchema s_e22ae74ff9113268; +extern const ::capnp::_::RawSchema s_f5fcba89c0c1196f; +extern const ::capnp::_::RawSchema s_f0fa30304066a4b3; +extern const ::capnp::_::RawSchema s_b727c0d0091a001d; +extern const ::capnp::_::RawSchema s_f77ed6f7454eec40; +extern const ::capnp::_::RawSchema s_c7485a3516c7d3c8; +extern const ::capnp::_::RawSchema s_db0afd413f4a313a; +extern const ::capnp::_::RawSchema s_cc85a335569990e9; +extern const ::capnp::_::RawSchema s_a017f0366827ee37; +extern const ::capnp::_::RawSchema s_94f7e0b103b4b718; +extern const ::capnp::_::RawSchema s_d9f2b5941a343bcd; +extern const ::capnp::_::RawSchema s_b651d2fba42056d4; +extern const ::capnp::_::RawSchema s_82cd03a53b29d76b; +extern const ::capnp::_::RawSchema s_cfa0d546993a3df3; +extern const ::capnp::_::RawSchema s_e78aac389e77b065; +extern const ::capnp::_::RawSchema s_e41885c94393277e; +extern const ::capnp::_::RawSchema s_8412c03b75b2cfee; +extern const ::capnp::_::RawSchema s_e0fe5870b141ad69; +extern const ::capnp::_::RawSchema s_a6411a353090145b; +extern const ::capnp::_::RawSchema s_a8abf7a82928986c; +extern const ::capnp::_::RawSchema s_ad7beedc4ed30742; +extern const ::capnp::_::RawSchema s_ef9a34f2ff7cc646; +extern const ::capnp::_::RawSchema s_c6abf1b0329e6227; +extern const ::capnp::_::RawSchema s_943a234ca336b16a; +extern const ::capnp::_::RawSchema s_8991bc0e74a594cd; +extern const ::capnp::_::RawSchema s_ed267416528c7a24; +extern const ::capnp::_::RawSchema s_9978837b037d58e6; +extern const ::capnp::_::RawSchema s_ed5fa940f54a7904; +extern const ::capnp::_::RawSchema s_bc743778f2597c7d; +extern const ::capnp::_::RawSchema s_c2e364a40182013d; +extern const ::capnp::_::RawSchema s_92fc29a80f3ddd5c; +extern const ::capnp::_::RawSchema s_a851ad32cbc2ffea; +extern const ::capnp::_::RawSchema s_a76e3c9bb7fd56d3; +extern const ::capnp::_::RawSchema s_807280a2901aa079; +extern const ::capnp::_::RawSchema s_c1973984dee98e3a; +extern const ::capnp::_::RawSchema s_95b30dd14e01dda8; +extern const ::capnp::_::RawSchema s_8ed75a7469f04ce3; +extern const ::capnp::_::RawSchema s_faf781ef89a00e39; +extern const ::capnp::_::RawSchema s_992edc677bef5a3c; +extern const ::capnp::_::RawSchema s_c5598844441096dc; +extern const ::capnp::_::RawSchema s_abed745cd8c92095; +extern const ::capnp::_::RawSchema s_d657409805207187; +extern const ::capnp::_::RawSchema s_bbe5b10ebd841165; +extern const ::capnp::_::RawSchema s_e4bf8760a0aded86; +extern const ::capnp::_::RawSchema s_9747fed267e18cab; +extern const ::capnp::_::RawSchema s_90794c40ae9ed82b; +extern const ::capnp::_::RawSchema s_c1834c909dfff36b; +extern const ::capnp::_::RawSchema s_8b9e0acc1bce0872; +extern const ::capnp::_::RawSchema s_a32c242eab4fd252; +extern const ::capnp::_::RawSchema s_b9c5472fc14639d5; +extern const ::capnp::_::RawSchema s_aae78676ba1dbcbb; +extern const ::capnp::_::RawSchema s_a25661f8942c24cc; +extern const ::capnp::_::RawSchema s_db2194bab1b25c48; +extern const ::capnp::_::RawSchema s_f346e8becc34c826; +extern const ::capnp::_::RawSchema s_aaa4fc67c55b78fd; +extern const ::capnp::_::RawSchema s_ed37d4414bf1157a; +extern const ::capnp::_::RawSchema s_f6a160eb0b3687fa; +extern const ::capnp::_::RawSchema s_e3201c2e657cf0fc; +extern const ::capnp::_::RawSchema s_ce1810c84e108cdc; +extern const ::capnp::_::RawSchema s_ff58bf5895b73ee2; +extern const ::capnp::_::RawSchema s_a145449a15848a09; +extern const ::capnp::_::RawSchema s_a567a743b6b4bf0d; +extern const ::capnp::_::RawSchema s_d987eb8af5945021; +extern const ::capnp::_::RawSchema s_9e55f87eb2ffa805; +extern const ::capnp::_::RawSchema s_fe4d1147d7537f4c; +extern const ::capnp::_::RawSchema s_900218d4541375d3; +extern const ::capnp::_::RawSchema s_d26dd7a486f26cd7; +extern const ::capnp::_::RawSchema s_feb875138580a065; +extern const ::capnp::_::RawSchema s_a815a514acbab212; +extern const ::capnp::_::RawSchema s_ec56db537c838603; +extern const ::capnp::_::RawSchema s_c468785db6321458; +extern const ::capnp::_::RawSchema s_d1f994d3d4fbbaed; +extern const ::capnp::_::RawSchema s_c30860d747fd5019; +extern const ::capnp::_::RawSchema s_ca4028a84b8fc2ed; +extern const ::capnp::_::RawSchema s_d81b65e268fb3f34; +extern const ::capnp::_::RawSchema s_bd579b448bfbcc7b; +extern const ::capnp::_::RawSchema s_a4764c3483341eeb; +extern const ::capnp::_::RawSchema s_88eb12a0e0af92b2; +extern const ::capnp::_::RawSchema s_b874edc0d559b391; +extern const ::capnp::_::RawSchema s_b04fcaddab714ba4; +extern const ::capnp::_::RawSchema s_d044893357b42568; +extern const ::capnp::_::RawSchema s_9bf141df4247d52f; +extern const ::capnp::_::RawSchema s_d9ac8abb2a91cfbc; +extern const ::capnp::_::RawSchema s_9b99d14f2f375b2d; +extern const ::capnp::_::RawSchema s_e4e9bac98670b748; +extern const ::capnp::_::RawSchema s_83a4bc5471363f17; +extern const ::capnp::_::RawSchema s_8e4b3d1a3e2753dd; +extern const ::capnp::_::RawSchema s_acf67532a7e7bad9; +extern const ::capnp::_::RawSchema s_f3b834e851ea8af6; +extern const ::capnp::_::RawSchema s_a5a404caa61d4cd0; +extern const ::capnp::_::RawSchema s_b0b29e51db0e26b1; +extern const ::capnp::_::RawSchema s_c7e8df5096257034; +extern const ::capnp::_::RawSchema s_b2442a9e0ba28fdf; +extern const ::capnp::_::RawSchema s_a604ee63cf37819f; +extern const ::capnp::_::RawSchema s_8eda54756c6070d6; +extern const ::capnp::_::RawSchema s_e02d3bbe1010e342; +extern const ::capnp::_::RawSchema s_aeb2ad168e2f5697; +extern const ::capnp::_::RawSchema s_ef428f2f67c4d439; +extern const ::capnp::_::RawSchema s_9e5c574772b1d462; +extern const ::capnp::_::RawSchema s_ea2fb7dca9cdbdea; +extern const ::capnp::_::RawSchema s_a805157b98b65469; +extern const ::capnp::_::RawSchema s_b589fd166c4f1f54; + +} // namespace schemas +namespace _ { // private + +CAPNP_DECLARE_ENUM( + ::capnproto_test::capnp::test::TestEnum, 9c8e9318b29d9cd3); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestAllTypes, a0a8f314b80b63fd, + 6, 20, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestDefaults, eb3f9ebe98c73cb6, + 6, 20, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestObject, d1f4434616a112ca, + 0, 1, POINTER); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestOutOfOrder, a9d5f8efe770022b, + 0, 9, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnion, f47697362233ce52, + 8, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnion::Union0, fc76a82eecb7a718, + 8, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnion::Union1, ee0a6b99b7dc7ab2, + 8, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnion::Union2, afc5fd419f0d66d4, + 8, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnion::Union3, a2fb022ec7f30053, + 8, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnnamedUnion, 9e2e784c915329b6, + 2, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnionInUnion, 89a9494f1b900f22, + 2, 0, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnionInUnion::Outer, d005f6c63707670c, + 2, 0, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnionInUnion::Outer::Inner, ff9ce111c6f8e5db, + 2, 0, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestGroups, dc841556134c3103, + 2, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestGroups::Groups, e22ae74ff9113268, + 2, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestGroups::Groups::Foo, f5fcba89c0c1196f, + 2, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestGroups::Groups::Baz, f0fa30304066a4b3, + 2, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestGroups::Groups::Bar, b727c0d0091a001d, + 2, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups, f77ed6f7454eec40, + 6, 6, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups::Group1, c7485a3516c7d3c8, + 6, 6, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups::Group1::Corge, db0afd413f4a313a, + 6, 6, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups::Group2, cc85a335569990e9, + 6, 6, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterleavedGroups::Group2::Corge, a017f0366827ee37, + 6, 6, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUnionDefaults, 94f7e0b103b4b718, + 0, 4, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestNestedTypes, d9f2b5941a343bcd, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_ENUM( + ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum, b651d2fba42056d4); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct, 82cd03a53b29d76b, + 1, 0, FOUR_BYTES); +CAPNP_DECLARE_ENUM( + ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum, cfa0d546993a3df3); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestUsing, e78aac389e77b065, + 1, 0, FOUR_BYTES); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists, e41885c94393277e, + 0, 10, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct0, 8412c03b75b2cfee, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct1, e0fe5870b141ad69, + 1, 0, BIT); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct8, a6411a353090145b, + 1, 0, BYTE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct16, a8abf7a82928986c, + 1, 0, TWO_BYTES); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct32, ad7beedc4ed30742, + 1, 0, FOUR_BYTES); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct64, ef9a34f2ff7cc646, + 1, 0, EIGHT_BYTES); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::StructP, c6abf1b0329e6227, + 0, 1, POINTER); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct0c, 943a234ca336b16a, + 0, 1, POINTER); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct1c, 8991bc0e74a594cd, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct8c, ed267416528c7a24, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct16c, 9978837b037d58e6, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct32c, ed5fa940f54a7904, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::Struct64c, bc743778f2597c7d, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLists::StructPc, c2e364a40182013d, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestFieldZeroIsBit, 92fc29a80f3ddd5c, + 1, 0, TWO_BYTES); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestListDefaults, a851ad32cbc2ffea, + 0, 1, POINTER); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLateUnion, a76e3c9bb7fd56d3, + 3, 3, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLateUnion::TheUnion, 807280a2901aa079, + 3, 3, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestLateUnion::AnotherUnion, c1973984dee98e3a, + 3, 3, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestOldVersion, 95b30dd14e01dda8, + 1, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestNewVersion, 8ed75a7469f04ce3, + 2, 3, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestStructUnion, faf781ef89a00e39, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestStructUnion::Un, 992edc677bef5a3c, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestEmptyStruct, c5598844441096dc, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestConstants, abed745cd8c92095, + 0, 0, VOID); +CAPNP_DECLARE_INTERFACE( + ::capnproto_test::capnp::test::TestInterface, 88eb12a0e0af92b2); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::FooParams, b874edc0d559b391, + 1, 0, EIGHT_BYTES); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::FooResults, b04fcaddab714ba4, + 0, 1, POINTER); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::BarParams, d044893357b42568, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::BarResults, 9bf141df4247d52f, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::BazParams, d9ac8abb2a91cfbc, + 0, 1, POINTER); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestInterface::BazResults, 9b99d14f2f375b2d, + 0, 0, VOID); +CAPNP_DECLARE_INTERFACE( + ::capnproto_test::capnp::test::TestExtends, e4e9bac98670b748); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestExtends::QuxParams, 83a4bc5471363f17, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestExtends::QuxResults, 8e4b3d1a3e2753dd, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestExtends::CorgeResults, acf67532a7e7bad9, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestExtends::GraultParams, f3b834e851ea8af6, + 0, 0, VOID); +CAPNP_DECLARE_INTERFACE( + ::capnproto_test::capnp::test::TestPipeline, a5a404caa61d4cd0); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::Box, b0b29e51db0e26b1, + 0, 1, POINTER); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::GetCapParams, c7e8df5096257034, + 1, 1, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::GetCapResults, b2442a9e0ba28fdf, + 0, 2, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::TestPointersParams, a604ee63cf37819f, + 0, 3, INLINE_COMPOSITE); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestPipeline::TestPointersResults, 8eda54756c6070d6, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestSturdyRefHostId, e02d3bbe1010e342, + 0, 1, POINTER); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestSturdyRefObjectId, aeb2ad168e2f5697, + 1, 0, TWO_BYTES); +CAPNP_DECLARE_ENUM( + ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag, ef428f2f67c4d439); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestProvisionId, 9e5c574772b1d462, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestRecipientId, ea2fb7dca9cdbdea, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestThirdPartyCapId, a805157b98b65469, + 0, 0, VOID); +CAPNP_DECLARE_STRUCT( + ::capnproto_test::capnp::test::TestJoinAnswer, b589fd166c4f1f54, + 0, 0, VOID); + +} // namespace _ (private) +} // namespace capnp + +// ======================================================================================= + +namespace capnproto_test { +namespace capnp { +namespace test { + +class TestAllTypes::Reader { +public: + typedef TestAllTypes Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasVoidField() const; + inline ::capnp::Void getVoidField() const; + + inline bool hasBoolField() const; + inline bool getBoolField() const; + + inline bool hasInt8Field() const; + inline ::int8_t getInt8Field() const; + + inline bool hasInt16Field() const; + inline ::int16_t getInt16Field() const; + + inline bool hasInt32Field() const; + inline ::int32_t getInt32Field() const; + + inline bool hasInt64Field() const; + inline ::int64_t getInt64Field() const; + + inline bool hasUInt8Field() const; + inline ::uint8_t getUInt8Field() const; + + inline bool hasUInt16Field() const; + inline ::uint16_t getUInt16Field() const; + + inline bool hasUInt32Field() const; + inline ::uint32_t getUInt32Field() const; + + inline bool hasUInt64Field() const; + inline ::uint64_t getUInt64Field() const; + + inline bool hasFloat32Field() const; + inline float getFloat32Field() const; + + inline bool hasFloat64Field() const; + inline double getFloat64Field() const; + + inline bool hasTextField() const; + inline ::capnp::Text::Reader getTextField() const; + + inline bool hasDataField() const; + inline ::capnp::Data::Reader getDataField() const; + + inline bool hasStructField() const; + inline ::capnproto_test::capnp::test::TestAllTypes::Reader getStructField() const; + + inline bool hasEnumField() const; + inline ::capnproto_test::capnp::test::TestEnum getEnumField() const; + + inline bool hasInterfaceField() const; + inline ::capnp::Void getInterfaceField() const; + + inline bool hasVoidList() const; + inline ::capnp::List< ::capnp::Void>::Reader getVoidList() const; + + inline bool hasBoolList() const; + inline ::capnp::List::Reader getBoolList() const; + + inline bool hasInt8List() const; + inline ::capnp::List< ::int8_t>::Reader getInt8List() const; + + inline bool hasInt16List() const; + inline ::capnp::List< ::int16_t>::Reader getInt16List() const; + + inline bool hasInt32List() const; + inline ::capnp::List< ::int32_t>::Reader getInt32List() const; + + inline bool hasInt64List() const; + inline ::capnp::List< ::int64_t>::Reader getInt64List() const; + + inline bool hasUInt8List() const; + inline ::capnp::List< ::uint8_t>::Reader getUInt8List() const; + + inline bool hasUInt16List() const; + inline ::capnp::List< ::uint16_t>::Reader getUInt16List() const; + + inline bool hasUInt32List() const; + inline ::capnp::List< ::uint32_t>::Reader getUInt32List() const; + + inline bool hasUInt64List() const; + inline ::capnp::List< ::uint64_t>::Reader getUInt64List() const; + + inline bool hasFloat32List() const; + inline ::capnp::List::Reader getFloat32List() const; + + inline bool hasFloat64List() const; + inline ::capnp::List::Reader getFloat64List() const; + + inline bool hasTextList() const; + inline ::capnp::List< ::capnp::Text>::Reader getTextList() const; + + inline bool hasDataList() const; + inline ::capnp::List< ::capnp::Data>::Reader getDataList() const; + + inline bool hasStructList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader getStructList() const; + + inline bool hasEnumList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Reader getEnumList() const; + + inline bool hasInterfaceList() const; + inline ::capnp::List< ::capnp::Void>::Reader getInterfaceList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestAllTypes::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestAllTypes::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestAllTypes::Builder { +public: + typedef TestAllTypes Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasVoidField(); + inline ::capnp::Void getVoidField(); + inline void setVoidField( ::capnp::Void value = ::capnp::VOID); + + inline bool hasBoolField(); + inline bool getBoolField(); + inline void setBoolField(bool value); + + inline bool hasInt8Field(); + inline ::int8_t getInt8Field(); + inline void setInt8Field( ::int8_t value); + + inline bool hasInt16Field(); + inline ::int16_t getInt16Field(); + inline void setInt16Field( ::int16_t value); + + inline bool hasInt32Field(); + inline ::int32_t getInt32Field(); + inline void setInt32Field( ::int32_t value); + + inline bool hasInt64Field(); + inline ::int64_t getInt64Field(); + inline void setInt64Field( ::int64_t value); + + inline bool hasUInt8Field(); + inline ::uint8_t getUInt8Field(); + inline void setUInt8Field( ::uint8_t value); + + inline bool hasUInt16Field(); + inline ::uint16_t getUInt16Field(); + inline void setUInt16Field( ::uint16_t value); + + inline bool hasUInt32Field(); + inline ::uint32_t getUInt32Field(); + inline void setUInt32Field( ::uint32_t value); + + inline bool hasUInt64Field(); + inline ::uint64_t getUInt64Field(); + inline void setUInt64Field( ::uint64_t value); + + inline bool hasFloat32Field(); + inline float getFloat32Field(); + inline void setFloat32Field(float value); + + inline bool hasFloat64Field(); + inline double getFloat64Field(); + inline void setFloat64Field(double value); + + inline bool hasTextField(); + inline ::capnp::Text::Builder getTextField(); + inline void setTextField( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTextField(unsigned int size); + inline void adoptTextField(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTextField(); + + inline bool hasDataField(); + inline ::capnp::Data::Builder getDataField(); + inline void setDataField( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initDataField(unsigned int size); + inline void adoptDataField(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownDataField(); + + inline bool hasStructField(); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder getStructField(); + inline void setStructField( ::capnproto_test::capnp::test::TestAllTypes::Reader value); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder initStructField(); + inline void adoptStructField(::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> disownStructField(); + + inline bool hasEnumField(); + inline ::capnproto_test::capnp::test::TestEnum getEnumField(); + inline void setEnumField( ::capnproto_test::capnp::test::TestEnum value); + + inline bool hasInterfaceField(); + inline ::capnp::Void getInterfaceField(); + inline void setInterfaceField( ::capnp::Void value = ::capnp::VOID); + + inline bool hasVoidList(); + inline ::capnp::List< ::capnp::Void>::Builder getVoidList(); + inline void setVoidList( ::capnp::List< ::capnp::Void>::Reader value); + inline void setVoidList(std::initializer_list< ::capnp::Void> value); + inline ::capnp::List< ::capnp::Void>::Builder initVoidList(unsigned int size); + inline void adoptVoidList(::capnp::Orphan< ::capnp::List< ::capnp::Void>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Void>> disownVoidList(); + + inline bool hasBoolList(); + inline ::capnp::List::Builder getBoolList(); + inline void setBoolList( ::capnp::List::Reader value); + inline void setBoolList(std::initializer_list value); + inline ::capnp::List::Builder initBoolList(unsigned int size); + inline void adoptBoolList(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownBoolList(); + + inline bool hasInt8List(); + inline ::capnp::List< ::int8_t>::Builder getInt8List(); + inline void setInt8List( ::capnp::List< ::int8_t>::Reader value); + inline void setInt8List(std::initializer_list< ::int8_t> value); + inline ::capnp::List< ::int8_t>::Builder initInt8List(unsigned int size); + inline void adoptInt8List(::capnp::Orphan< ::capnp::List< ::int8_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int8_t>> disownInt8List(); + + inline bool hasInt16List(); + inline ::capnp::List< ::int16_t>::Builder getInt16List(); + inline void setInt16List( ::capnp::List< ::int16_t>::Reader value); + inline void setInt16List(std::initializer_list< ::int16_t> value); + inline ::capnp::List< ::int16_t>::Builder initInt16List(unsigned int size); + inline void adoptInt16List(::capnp::Orphan< ::capnp::List< ::int16_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int16_t>> disownInt16List(); + + inline bool hasInt32List(); + inline ::capnp::List< ::int32_t>::Builder getInt32List(); + inline void setInt32List( ::capnp::List< ::int32_t>::Reader value); + inline void setInt32List(std::initializer_list< ::int32_t> value); + inline ::capnp::List< ::int32_t>::Builder initInt32List(unsigned int size); + inline void adoptInt32List(::capnp::Orphan< ::capnp::List< ::int32_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t>> disownInt32List(); + + inline bool hasInt64List(); + inline ::capnp::List< ::int64_t>::Builder getInt64List(); + inline void setInt64List( ::capnp::List< ::int64_t>::Reader value); + inline void setInt64List(std::initializer_list< ::int64_t> value); + inline ::capnp::List< ::int64_t>::Builder initInt64List(unsigned int size); + inline void adoptInt64List(::capnp::Orphan< ::capnp::List< ::int64_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int64_t>> disownInt64List(); + + inline bool hasUInt8List(); + inline ::capnp::List< ::uint8_t>::Builder getUInt8List(); + inline void setUInt8List( ::capnp::List< ::uint8_t>::Reader value); + inline void setUInt8List(std::initializer_list< ::uint8_t> value); + inline ::capnp::List< ::uint8_t>::Builder initUInt8List(unsigned int size); + inline void adoptUInt8List(::capnp::Orphan< ::capnp::List< ::uint8_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint8_t>> disownUInt8List(); + + inline bool hasUInt16List(); + inline ::capnp::List< ::uint16_t>::Builder getUInt16List(); + inline void setUInt16List( ::capnp::List< ::uint16_t>::Reader value); + inline void setUInt16List(std::initializer_list< ::uint16_t> value); + inline ::capnp::List< ::uint16_t>::Builder initUInt16List(unsigned int size); + inline void adoptUInt16List(::capnp::Orphan< ::capnp::List< ::uint16_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint16_t>> disownUInt16List(); + + inline bool hasUInt32List(); + inline ::capnp::List< ::uint32_t>::Builder getUInt32List(); + inline void setUInt32List( ::capnp::List< ::uint32_t>::Reader value); + inline void setUInt32List(std::initializer_list< ::uint32_t> value); + inline ::capnp::List< ::uint32_t>::Builder initUInt32List(unsigned int size); + inline void adoptUInt32List(::capnp::Orphan< ::capnp::List< ::uint32_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t>> disownUInt32List(); + + inline bool hasUInt64List(); + inline ::capnp::List< ::uint64_t>::Builder getUInt64List(); + inline void setUInt64List( ::capnp::List< ::uint64_t>::Reader value); + inline void setUInt64List(std::initializer_list< ::uint64_t> value); + inline ::capnp::List< ::uint64_t>::Builder initUInt64List(unsigned int size); + inline void adoptUInt64List(::capnp::Orphan< ::capnp::List< ::uint64_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t>> disownUInt64List(); + + inline bool hasFloat32List(); + inline ::capnp::List::Builder getFloat32List(); + inline void setFloat32List( ::capnp::List::Reader value); + inline void setFloat32List(std::initializer_list value); + inline ::capnp::List::Builder initFloat32List(unsigned int size); + inline void adoptFloat32List(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat32List(); + + inline bool hasFloat64List(); + inline ::capnp::List::Builder getFloat64List(); + inline void setFloat64List( ::capnp::List::Reader value); + inline void setFloat64List(std::initializer_list value); + inline ::capnp::List::Builder initFloat64List(unsigned int size); + inline void adoptFloat64List(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat64List(); + + inline bool hasTextList(); + inline ::capnp::List< ::capnp::Text>::Builder getTextList(); + inline void setTextList( ::capnp::List< ::capnp::Text>::Reader value); + inline void setTextList(std::initializer_list< ::capnp::Text::Reader> value); + inline ::capnp::List< ::capnp::Text>::Builder initTextList(unsigned int size); + inline void adoptTextList(::capnp::Orphan< ::capnp::List< ::capnp::Text>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text>> disownTextList(); + + inline bool hasDataList(); + inline ::capnp::List< ::capnp::Data>::Builder getDataList(); + inline void setDataList( ::capnp::List< ::capnp::Data>::Reader value); + inline void setDataList(std::initializer_list< ::capnp::Data::Reader> value); + inline ::capnp::List< ::capnp::Data>::Builder initDataList(unsigned int size); + inline void adoptDataList(::capnp::Orphan< ::capnp::List< ::capnp::Data>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Data>> disownDataList(); + + inline bool hasStructList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Builder getStructList(); + inline void setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Builder initStructList(unsigned int size); + inline void adoptStructList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>> disownStructList(); + + inline bool hasEnumList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Builder getEnumList(); + inline void setEnumList( ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Reader value); + inline void setEnumList(std::initializer_list< ::capnproto_test::capnp::test::TestEnum> value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Builder initEnumList(unsigned int size); + inline void adoptEnumList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>> disownEnumList(); + + inline bool hasInterfaceList(); + inline ::capnp::List< ::capnp::Void>::Builder getInterfaceList(); + inline void setInterfaceList( ::capnp::List< ::capnp::Void>::Reader value); + inline void setInterfaceList(std::initializer_list< ::capnp::Void> value); + inline ::capnp::List< ::capnp::Void>::Builder initInterfaceList(unsigned int size); + inline void adoptInterfaceList(::capnp::Orphan< ::capnp::List< ::capnp::Void>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Void>> disownInterfaceList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestAllTypes::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestAllTypes::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestAllTypes::Pipeline { +public: + typedef TestAllTypes Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline getStructField() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestDefaults::Reader { +public: + typedef TestDefaults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasVoidField() const; + inline ::capnp::Void getVoidField() const; + + inline bool hasBoolField() const; + inline bool getBoolField() const; + + inline bool hasInt8Field() const; + inline ::int8_t getInt8Field() const; + + inline bool hasInt16Field() const; + inline ::int16_t getInt16Field() const; + + inline bool hasInt32Field() const; + inline ::int32_t getInt32Field() const; + + inline bool hasInt64Field() const; + inline ::int64_t getInt64Field() const; + + inline bool hasUInt8Field() const; + inline ::uint8_t getUInt8Field() const; + + inline bool hasUInt16Field() const; + inline ::uint16_t getUInt16Field() const; + + inline bool hasUInt32Field() const; + inline ::uint32_t getUInt32Field() const; + + inline bool hasUInt64Field() const; + inline ::uint64_t getUInt64Field() const; + + inline bool hasFloat32Field() const; + inline float getFloat32Field() const; + + inline bool hasFloat64Field() const; + inline double getFloat64Field() const; + + inline bool hasTextField() const; + inline ::capnp::Text::Reader getTextField() const; + + inline bool hasDataField() const; + inline ::capnp::Data::Reader getDataField() const; + + inline bool hasStructField() const; + inline ::capnproto_test::capnp::test::TestAllTypes::Reader getStructField() const; + + inline bool hasEnumField() const; + inline ::capnproto_test::capnp::test::TestEnum getEnumField() const; + + inline bool hasInterfaceField() const; + inline ::capnp::Void getInterfaceField() const; + + inline bool hasVoidList() const; + inline ::capnp::List< ::capnp::Void>::Reader getVoidList() const; + + inline bool hasBoolList() const; + inline ::capnp::List::Reader getBoolList() const; + + inline bool hasInt8List() const; + inline ::capnp::List< ::int8_t>::Reader getInt8List() const; + + inline bool hasInt16List() const; + inline ::capnp::List< ::int16_t>::Reader getInt16List() const; + + inline bool hasInt32List() const; + inline ::capnp::List< ::int32_t>::Reader getInt32List() const; + + inline bool hasInt64List() const; + inline ::capnp::List< ::int64_t>::Reader getInt64List() const; + + inline bool hasUInt8List() const; + inline ::capnp::List< ::uint8_t>::Reader getUInt8List() const; + + inline bool hasUInt16List() const; + inline ::capnp::List< ::uint16_t>::Reader getUInt16List() const; + + inline bool hasUInt32List() const; + inline ::capnp::List< ::uint32_t>::Reader getUInt32List() const; + + inline bool hasUInt64List() const; + inline ::capnp::List< ::uint64_t>::Reader getUInt64List() const; + + inline bool hasFloat32List() const; + inline ::capnp::List::Reader getFloat32List() const; + + inline bool hasFloat64List() const; + inline ::capnp::List::Reader getFloat64List() const; + + inline bool hasTextList() const; + inline ::capnp::List< ::capnp::Text>::Reader getTextList() const; + + inline bool hasDataList() const; + inline ::capnp::List< ::capnp::Data>::Reader getDataList() const; + + inline bool hasStructList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader getStructList() const; + + inline bool hasEnumList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Reader getEnumList() const; + + inline bool hasInterfaceList() const; + inline ::capnp::List< ::capnp::Void>::Reader getInterfaceList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestDefaults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestDefaults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestDefaults::Builder { +public: + typedef TestDefaults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasVoidField(); + inline ::capnp::Void getVoidField(); + inline void setVoidField( ::capnp::Void value = ::capnp::VOID); + + inline bool hasBoolField(); + inline bool getBoolField(); + inline void setBoolField(bool value); + + inline bool hasInt8Field(); + inline ::int8_t getInt8Field(); + inline void setInt8Field( ::int8_t value); + + inline bool hasInt16Field(); + inline ::int16_t getInt16Field(); + inline void setInt16Field( ::int16_t value); + + inline bool hasInt32Field(); + inline ::int32_t getInt32Field(); + inline void setInt32Field( ::int32_t value); + + inline bool hasInt64Field(); + inline ::int64_t getInt64Field(); + inline void setInt64Field( ::int64_t value); + + inline bool hasUInt8Field(); + inline ::uint8_t getUInt8Field(); + inline void setUInt8Field( ::uint8_t value); + + inline bool hasUInt16Field(); + inline ::uint16_t getUInt16Field(); + inline void setUInt16Field( ::uint16_t value); + + inline bool hasUInt32Field(); + inline ::uint32_t getUInt32Field(); + inline void setUInt32Field( ::uint32_t value); + + inline bool hasUInt64Field(); + inline ::uint64_t getUInt64Field(); + inline void setUInt64Field( ::uint64_t value); + + inline bool hasFloat32Field(); + inline float getFloat32Field(); + inline void setFloat32Field(float value); + + inline bool hasFloat64Field(); + inline double getFloat64Field(); + inline void setFloat64Field(double value); + + inline bool hasTextField(); + inline ::capnp::Text::Builder getTextField(); + inline void setTextField( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initTextField(unsigned int size); + inline void adoptTextField(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownTextField(); + + inline bool hasDataField(); + inline ::capnp::Data::Builder getDataField(); + inline void setDataField( ::capnp::Data::Reader value); + inline ::capnp::Data::Builder initDataField(unsigned int size); + inline void adoptDataField(::capnp::Orphan< ::capnp::Data>&& value); + inline ::capnp::Orphan< ::capnp::Data> disownDataField(); + + inline bool hasStructField(); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder getStructField(); + inline void setStructField( ::capnproto_test::capnp::test::TestAllTypes::Reader value); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder initStructField(); + inline void adoptStructField(::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> disownStructField(); + + inline bool hasEnumField(); + inline ::capnproto_test::capnp::test::TestEnum getEnumField(); + inline void setEnumField( ::capnproto_test::capnp::test::TestEnum value); + + inline bool hasInterfaceField(); + inline ::capnp::Void getInterfaceField(); + inline void setInterfaceField( ::capnp::Void value = ::capnp::VOID); + + inline bool hasVoidList(); + inline ::capnp::List< ::capnp::Void>::Builder getVoidList(); + inline void setVoidList( ::capnp::List< ::capnp::Void>::Reader value); + inline void setVoidList(std::initializer_list< ::capnp::Void> value); + inline ::capnp::List< ::capnp::Void>::Builder initVoidList(unsigned int size); + inline void adoptVoidList(::capnp::Orphan< ::capnp::List< ::capnp::Void>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Void>> disownVoidList(); + + inline bool hasBoolList(); + inline ::capnp::List::Builder getBoolList(); + inline void setBoolList( ::capnp::List::Reader value); + inline void setBoolList(std::initializer_list value); + inline ::capnp::List::Builder initBoolList(unsigned int size); + inline void adoptBoolList(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownBoolList(); + + inline bool hasInt8List(); + inline ::capnp::List< ::int8_t>::Builder getInt8List(); + inline void setInt8List( ::capnp::List< ::int8_t>::Reader value); + inline void setInt8List(std::initializer_list< ::int8_t> value); + inline ::capnp::List< ::int8_t>::Builder initInt8List(unsigned int size); + inline void adoptInt8List(::capnp::Orphan< ::capnp::List< ::int8_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int8_t>> disownInt8List(); + + inline bool hasInt16List(); + inline ::capnp::List< ::int16_t>::Builder getInt16List(); + inline void setInt16List( ::capnp::List< ::int16_t>::Reader value); + inline void setInt16List(std::initializer_list< ::int16_t> value); + inline ::capnp::List< ::int16_t>::Builder initInt16List(unsigned int size); + inline void adoptInt16List(::capnp::Orphan< ::capnp::List< ::int16_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int16_t>> disownInt16List(); + + inline bool hasInt32List(); + inline ::capnp::List< ::int32_t>::Builder getInt32List(); + inline void setInt32List( ::capnp::List< ::int32_t>::Reader value); + inline void setInt32List(std::initializer_list< ::int32_t> value); + inline ::capnp::List< ::int32_t>::Builder initInt32List(unsigned int size); + inline void adoptInt32List(::capnp::Orphan< ::capnp::List< ::int32_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t>> disownInt32List(); + + inline bool hasInt64List(); + inline ::capnp::List< ::int64_t>::Builder getInt64List(); + inline void setInt64List( ::capnp::List< ::int64_t>::Reader value); + inline void setInt64List(std::initializer_list< ::int64_t> value); + inline ::capnp::List< ::int64_t>::Builder initInt64List(unsigned int size); + inline void adoptInt64List(::capnp::Orphan< ::capnp::List< ::int64_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int64_t>> disownInt64List(); + + inline bool hasUInt8List(); + inline ::capnp::List< ::uint8_t>::Builder getUInt8List(); + inline void setUInt8List( ::capnp::List< ::uint8_t>::Reader value); + inline void setUInt8List(std::initializer_list< ::uint8_t> value); + inline ::capnp::List< ::uint8_t>::Builder initUInt8List(unsigned int size); + inline void adoptUInt8List(::capnp::Orphan< ::capnp::List< ::uint8_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint8_t>> disownUInt8List(); + + inline bool hasUInt16List(); + inline ::capnp::List< ::uint16_t>::Builder getUInt16List(); + inline void setUInt16List( ::capnp::List< ::uint16_t>::Reader value); + inline void setUInt16List(std::initializer_list< ::uint16_t> value); + inline ::capnp::List< ::uint16_t>::Builder initUInt16List(unsigned int size); + inline void adoptUInt16List(::capnp::Orphan< ::capnp::List< ::uint16_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint16_t>> disownUInt16List(); + + inline bool hasUInt32List(); + inline ::capnp::List< ::uint32_t>::Builder getUInt32List(); + inline void setUInt32List( ::capnp::List< ::uint32_t>::Reader value); + inline void setUInt32List(std::initializer_list< ::uint32_t> value); + inline ::capnp::List< ::uint32_t>::Builder initUInt32List(unsigned int size); + inline void adoptUInt32List(::capnp::Orphan< ::capnp::List< ::uint32_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint32_t>> disownUInt32List(); + + inline bool hasUInt64List(); + inline ::capnp::List< ::uint64_t>::Builder getUInt64List(); + inline void setUInt64List( ::capnp::List< ::uint64_t>::Reader value); + inline void setUInt64List(std::initializer_list< ::uint64_t> value); + inline ::capnp::List< ::uint64_t>::Builder initUInt64List(unsigned int size); + inline void adoptUInt64List(::capnp::Orphan< ::capnp::List< ::uint64_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::uint64_t>> disownUInt64List(); + + inline bool hasFloat32List(); + inline ::capnp::List::Builder getFloat32List(); + inline void setFloat32List( ::capnp::List::Reader value); + inline void setFloat32List(std::initializer_list value); + inline ::capnp::List::Builder initFloat32List(unsigned int size); + inline void adoptFloat32List(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat32List(); + + inline bool hasFloat64List(); + inline ::capnp::List::Builder getFloat64List(); + inline void setFloat64List( ::capnp::List::Reader value); + inline void setFloat64List(std::initializer_list value); + inline ::capnp::List::Builder initFloat64List(unsigned int size); + inline void adoptFloat64List(::capnp::Orphan< ::capnp::List>&& value); + inline ::capnp::Orphan< ::capnp::List> disownFloat64List(); + + inline bool hasTextList(); + inline ::capnp::List< ::capnp::Text>::Builder getTextList(); + inline void setTextList( ::capnp::List< ::capnp::Text>::Reader value); + inline void setTextList(std::initializer_list< ::capnp::Text::Reader> value); + inline ::capnp::List< ::capnp::Text>::Builder initTextList(unsigned int size); + inline void adoptTextList(::capnp::Orphan< ::capnp::List< ::capnp::Text>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Text>> disownTextList(); + + inline bool hasDataList(); + inline ::capnp::List< ::capnp::Data>::Builder getDataList(); + inline void setDataList( ::capnp::List< ::capnp::Data>::Reader value); + inline void setDataList(std::initializer_list< ::capnp::Data::Reader> value); + inline ::capnp::List< ::capnp::Data>::Builder initDataList(unsigned int size); + inline void adoptDataList(::capnp::Orphan< ::capnp::List< ::capnp::Data>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Data>> disownDataList(); + + inline bool hasStructList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Builder getStructList(); + inline void setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Builder initStructList(unsigned int size); + inline void adoptStructList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>> disownStructList(); + + inline bool hasEnumList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Builder getEnumList(); + inline void setEnumList( ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Reader value); + inline void setEnumList(std::initializer_list< ::capnproto_test::capnp::test::TestEnum> value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Builder initEnumList(unsigned int size); + inline void adoptEnumList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>> disownEnumList(); + + inline bool hasInterfaceList(); + inline ::capnp::List< ::capnp::Void>::Builder getInterfaceList(); + inline void setInterfaceList( ::capnp::List< ::capnp::Void>::Reader value); + inline void setInterfaceList(std::initializer_list< ::capnp::Void> value); + inline ::capnp::List< ::capnp::Void>::Builder initInterfaceList(unsigned int size); + inline void adoptInterfaceList(::capnp::Orphan< ::capnp::List< ::capnp::Void>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::Void>> disownInterfaceList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestDefaults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestDefaults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestDefaults::Pipeline { +public: + typedef TestDefaults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline getStructField() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestObject::Reader { +public: + typedef TestObject Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasObjectField() const; + inline ::capnp::ObjectPointer::Reader getObjectField() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestObject::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestObject::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestObject::Builder { +public: + typedef TestObject Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasObjectField(); + inline ::capnp::ObjectPointer::Builder getObjectField(); + inline ::capnp::ObjectPointer::Builder initObjectField(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestObject::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestObject::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestObject::Pipeline { +public: + typedef TestObject Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestOutOfOrder::Reader { +public: + typedef TestOutOfOrder Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasQux() const; + inline ::capnp::Text::Reader getQux() const; + + inline bool hasGrault() const; + inline ::capnp::Text::Reader getGrault() const; + + inline bool hasBar() const; + inline ::capnp::Text::Reader getBar() const; + + inline bool hasFoo() const; + inline ::capnp::Text::Reader getFoo() const; + + inline bool hasCorge() const; + inline ::capnp::Text::Reader getCorge() const; + + inline bool hasWaldo() const; + inline ::capnp::Text::Reader getWaldo() const; + + inline bool hasQuux() const; + inline ::capnp::Text::Reader getQuux() const; + + inline bool hasGarply() const; + inline ::capnp::Text::Reader getGarply() const; + + inline bool hasBaz() const; + inline ::capnp::Text::Reader getBaz() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestOutOfOrder::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestOutOfOrder::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestOutOfOrder::Builder { +public: + typedef TestOutOfOrder Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasQux(); + inline ::capnp::Text::Builder getQux(); + inline void setQux( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQux(unsigned int size); + inline void adoptQux(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQux(); + + inline bool hasGrault(); + inline ::capnp::Text::Builder getGrault(); + inline void setGrault( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGrault(unsigned int size); + inline void adoptGrault(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGrault(); + + inline bool hasBar(); + inline ::capnp::Text::Builder getBar(); + inline void setBar( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownBar(); + + inline bool hasFoo(); + inline ::capnp::Text::Builder getFoo(); + inline void setFoo( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFoo(unsigned int size); + inline void adoptFoo(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFoo(); + + inline bool hasCorge(); + inline ::capnp::Text::Builder getCorge(); + inline void setCorge( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initCorge(unsigned int size); + inline void adoptCorge(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownCorge(); + + inline bool hasWaldo(); + inline ::capnp::Text::Builder getWaldo(); + inline void setWaldo( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initWaldo(unsigned int size); + inline void adoptWaldo(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownWaldo(); + + inline bool hasQuux(); + inline ::capnp::Text::Builder getQuux(); + inline void setQuux( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQuux(unsigned int size); + inline void adoptQuux(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQuux(); + + inline bool hasGarply(); + inline ::capnp::Text::Builder getGarply(); + inline void setGarply( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGarply(unsigned int size); + inline void adoptGarply(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGarply(); + + inline bool hasBaz(); + inline ::capnp::Text::Builder getBaz(); + inline void setBaz( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initBaz(unsigned int size); + inline void adoptBaz(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownBaz(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestOutOfOrder::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestOutOfOrder::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestOutOfOrder::Pipeline { +public: + typedef TestOutOfOrder Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnion::Reader { +public: + typedef TestUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasUnion0() const; + inline Union0::Reader getUnion0() const; + + inline bool hasUnion1() const; + inline Union1::Reader getUnion1() const; + + inline bool hasUnion2() const; + inline Union2::Reader getUnion2() const; + + inline bool hasUnion3() const; + inline Union3::Reader getUnion3() const; + + inline bool hasBit0() const; + inline bool getBit0() const; + + inline bool hasBit2() const; + inline bool getBit2() const; + + inline bool hasBit3() const; + inline bool getBit3() const; + + inline bool hasBit4() const; + inline bool getBit4() const; + + inline bool hasBit5() const; + inline bool getBit5() const; + + inline bool hasBit6() const; + inline bool getBit6() const; + + inline bool hasBit7() const; + inline bool getBit7() const; + + inline bool hasByte0() const; + inline ::uint8_t getByte0() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnion::Builder { +public: + typedef TestUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasUnion0(); + inline Union0::Builder getUnion0(); + inline Union0::Builder initUnion0(); + + inline bool hasUnion1(); + inline Union1::Builder getUnion1(); + inline Union1::Builder initUnion1(); + + inline bool hasUnion2(); + inline Union2::Builder getUnion2(); + inline Union2::Builder initUnion2(); + + inline bool hasUnion3(); + inline Union3::Builder getUnion3(); + inline Union3::Builder initUnion3(); + + inline bool hasBit0(); + inline bool getBit0(); + inline void setBit0(bool value); + + inline bool hasBit2(); + inline bool getBit2(); + inline void setBit2(bool value); + + inline bool hasBit3(); + inline bool getBit3(); + inline void setBit3(bool value); + + inline bool hasBit4(); + inline bool getBit4(); + inline void setBit4(bool value); + + inline bool hasBit5(); + inline bool getBit5(); + inline void setBit5(bool value); + + inline bool hasBit6(); + inline bool getBit6(); + inline void setBit6(bool value); + + inline bool hasBit7(); + inline bool getBit7(); + inline void setBit7(bool value); + + inline bool hasByte0(); + inline ::uint8_t getByte0(); + inline void setByte0( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnion::Pipeline { +public: + typedef TestUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline Union0::Pipeline getUnion0() const; + inline Union1::Pipeline getUnion1() const; + inline Union2::Pipeline getUnion2() const; + inline Union3::Pipeline getUnion3() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnion::Union0::Reader { +public: + typedef Union0 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isU0f0s0() const; + inline bool hasU0f0s0() const; + inline ::capnp::Void getU0f0s0() const; + + inline bool isU0f0s1() const; + inline bool hasU0f0s1() const; + inline bool getU0f0s1() const; + + inline bool isU0f0s8() const; + inline bool hasU0f0s8() const; + inline ::int8_t getU0f0s8() const; + + inline bool isU0f0s16() const; + inline bool hasU0f0s16() const; + inline ::int16_t getU0f0s16() const; + + inline bool isU0f0s32() const; + inline bool hasU0f0s32() const; + inline ::int32_t getU0f0s32() const; + + inline bool isU0f0s64() const; + inline bool hasU0f0s64() const; + inline ::int64_t getU0f0s64() const; + + inline bool isU0f0sp() const; + inline bool hasU0f0sp() const; + inline ::capnp::Text::Reader getU0f0sp() const; + + inline bool isU0f1s0() const; + inline bool hasU0f1s0() const; + inline ::capnp::Void getU0f1s0() const; + + inline bool isU0f1s1() const; + inline bool hasU0f1s1() const; + inline bool getU0f1s1() const; + + inline bool isU0f1s8() const; + inline bool hasU0f1s8() const; + inline ::int8_t getU0f1s8() const; + + inline bool isU0f1s16() const; + inline bool hasU0f1s16() const; + inline ::int16_t getU0f1s16() const; + + inline bool isU0f1s32() const; + inline bool hasU0f1s32() const; + inline ::int32_t getU0f1s32() const; + + inline bool isU0f1s64() const; + inline bool hasU0f1s64() const; + inline ::int64_t getU0f1s64() const; + + inline bool isU0f1sp() const; + inline bool hasU0f1sp() const; + inline ::capnp::Text::Reader getU0f1sp() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Union0::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Union0::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnion::Union0::Builder { +public: + typedef Union0 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isU0f0s0(); + inline bool hasU0f0s0(); + inline ::capnp::Void getU0f0s0(); + inline void setU0f0s0( ::capnp::Void value = ::capnp::VOID); + + inline bool isU0f0s1(); + inline bool hasU0f0s1(); + inline bool getU0f0s1(); + inline void setU0f0s1(bool value); + + inline bool isU0f0s8(); + inline bool hasU0f0s8(); + inline ::int8_t getU0f0s8(); + inline void setU0f0s8( ::int8_t value); + + inline bool isU0f0s16(); + inline bool hasU0f0s16(); + inline ::int16_t getU0f0s16(); + inline void setU0f0s16( ::int16_t value); + + inline bool isU0f0s32(); + inline bool hasU0f0s32(); + inline ::int32_t getU0f0s32(); + inline void setU0f0s32( ::int32_t value); + + inline bool isU0f0s64(); + inline bool hasU0f0s64(); + inline ::int64_t getU0f0s64(); + inline void setU0f0s64( ::int64_t value); + + inline bool isU0f0sp(); + inline bool hasU0f0sp(); + inline ::capnp::Text::Builder getU0f0sp(); + inline void setU0f0sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU0f0sp(unsigned int size); + inline void adoptU0f0sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU0f0sp(); + + inline bool isU0f1s0(); + inline bool hasU0f1s0(); + inline ::capnp::Void getU0f1s0(); + inline void setU0f1s0( ::capnp::Void value = ::capnp::VOID); + + inline bool isU0f1s1(); + inline bool hasU0f1s1(); + inline bool getU0f1s1(); + inline void setU0f1s1(bool value); + + inline bool isU0f1s8(); + inline bool hasU0f1s8(); + inline ::int8_t getU0f1s8(); + inline void setU0f1s8( ::int8_t value); + + inline bool isU0f1s16(); + inline bool hasU0f1s16(); + inline ::int16_t getU0f1s16(); + inline void setU0f1s16( ::int16_t value); + + inline bool isU0f1s32(); + inline bool hasU0f1s32(); + inline ::int32_t getU0f1s32(); + inline void setU0f1s32( ::int32_t value); + + inline bool isU0f1s64(); + inline bool hasU0f1s64(); + inline ::int64_t getU0f1s64(); + inline void setU0f1s64( ::int64_t value); + + inline bool isU0f1sp(); + inline bool hasU0f1sp(); + inline ::capnp::Text::Builder getU0f1sp(); + inline void setU0f1sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU0f1sp(unsigned int size); + inline void adoptU0f1sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU0f1sp(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Union0::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Union0::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnion::Union0::Pipeline { +public: + typedef Union0 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnion::Union1::Reader { +public: + typedef Union1 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isU1f0s0() const; + inline bool hasU1f0s0() const; + inline ::capnp::Void getU1f0s0() const; + + inline bool isU1f0s1() const; + inline bool hasU1f0s1() const; + inline bool getU1f0s1() const; + + inline bool isU1f1s1() const; + inline bool hasU1f1s1() const; + inline bool getU1f1s1() const; + + inline bool isU1f0s8() const; + inline bool hasU1f0s8() const; + inline ::int8_t getU1f0s8() const; + + inline bool isU1f1s8() const; + inline bool hasU1f1s8() const; + inline ::int8_t getU1f1s8() const; + + inline bool isU1f0s16() const; + inline bool hasU1f0s16() const; + inline ::int16_t getU1f0s16() const; + + inline bool isU1f1s16() const; + inline bool hasU1f1s16() const; + inline ::int16_t getU1f1s16() const; + + inline bool isU1f0s32() const; + inline bool hasU1f0s32() const; + inline ::int32_t getU1f0s32() const; + + inline bool isU1f1s32() const; + inline bool hasU1f1s32() const; + inline ::int32_t getU1f1s32() const; + + inline bool isU1f0s64() const; + inline bool hasU1f0s64() const; + inline ::int64_t getU1f0s64() const; + + inline bool isU1f1s64() const; + inline bool hasU1f1s64() const; + inline ::int64_t getU1f1s64() const; + + inline bool isU1f0sp() const; + inline bool hasU1f0sp() const; + inline ::capnp::Text::Reader getU1f0sp() const; + + inline bool isU1f1sp() const; + inline bool hasU1f1sp() const; + inline ::capnp::Text::Reader getU1f1sp() const; + + inline bool isU1f2s0() const; + inline bool hasU1f2s0() const; + inline ::capnp::Void getU1f2s0() const; + + inline bool isU1f2s1() const; + inline bool hasU1f2s1() const; + inline bool getU1f2s1() const; + + inline bool isU1f2s8() const; + inline bool hasU1f2s8() const; + inline ::int8_t getU1f2s8() const; + + inline bool isU1f2s16() const; + inline bool hasU1f2s16() const; + inline ::int16_t getU1f2s16() const; + + inline bool isU1f2s32() const; + inline bool hasU1f2s32() const; + inline ::int32_t getU1f2s32() const; + + inline bool isU1f2s64() const; + inline bool hasU1f2s64() const; + inline ::int64_t getU1f2s64() const; + + inline bool isU1f2sp() const; + inline bool hasU1f2sp() const; + inline ::capnp::Text::Reader getU1f2sp() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Union1::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Union1::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnion::Union1::Builder { +public: + typedef Union1 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isU1f0s0(); + inline bool hasU1f0s0(); + inline ::capnp::Void getU1f0s0(); + inline void setU1f0s0( ::capnp::Void value = ::capnp::VOID); + + inline bool isU1f0s1(); + inline bool hasU1f0s1(); + inline bool getU1f0s1(); + inline void setU1f0s1(bool value); + + inline bool isU1f1s1(); + inline bool hasU1f1s1(); + inline bool getU1f1s1(); + inline void setU1f1s1(bool value); + + inline bool isU1f0s8(); + inline bool hasU1f0s8(); + inline ::int8_t getU1f0s8(); + inline void setU1f0s8( ::int8_t value); + + inline bool isU1f1s8(); + inline bool hasU1f1s8(); + inline ::int8_t getU1f1s8(); + inline void setU1f1s8( ::int8_t value); + + inline bool isU1f0s16(); + inline bool hasU1f0s16(); + inline ::int16_t getU1f0s16(); + inline void setU1f0s16( ::int16_t value); + + inline bool isU1f1s16(); + inline bool hasU1f1s16(); + inline ::int16_t getU1f1s16(); + inline void setU1f1s16( ::int16_t value); + + inline bool isU1f0s32(); + inline bool hasU1f0s32(); + inline ::int32_t getU1f0s32(); + inline void setU1f0s32( ::int32_t value); + + inline bool isU1f1s32(); + inline bool hasU1f1s32(); + inline ::int32_t getU1f1s32(); + inline void setU1f1s32( ::int32_t value); + + inline bool isU1f0s64(); + inline bool hasU1f0s64(); + inline ::int64_t getU1f0s64(); + inline void setU1f0s64( ::int64_t value); + + inline bool isU1f1s64(); + inline bool hasU1f1s64(); + inline ::int64_t getU1f1s64(); + inline void setU1f1s64( ::int64_t value); + + inline bool isU1f0sp(); + inline bool hasU1f0sp(); + inline ::capnp::Text::Builder getU1f0sp(); + inline void setU1f0sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU1f0sp(unsigned int size); + inline void adoptU1f0sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU1f0sp(); + + inline bool isU1f1sp(); + inline bool hasU1f1sp(); + inline ::capnp::Text::Builder getU1f1sp(); + inline void setU1f1sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU1f1sp(unsigned int size); + inline void adoptU1f1sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU1f1sp(); + + inline bool isU1f2s0(); + inline bool hasU1f2s0(); + inline ::capnp::Void getU1f2s0(); + inline void setU1f2s0( ::capnp::Void value = ::capnp::VOID); + + inline bool isU1f2s1(); + inline bool hasU1f2s1(); + inline bool getU1f2s1(); + inline void setU1f2s1(bool value); + + inline bool isU1f2s8(); + inline bool hasU1f2s8(); + inline ::int8_t getU1f2s8(); + inline void setU1f2s8( ::int8_t value); + + inline bool isU1f2s16(); + inline bool hasU1f2s16(); + inline ::int16_t getU1f2s16(); + inline void setU1f2s16( ::int16_t value); + + inline bool isU1f2s32(); + inline bool hasU1f2s32(); + inline ::int32_t getU1f2s32(); + inline void setU1f2s32( ::int32_t value); + + inline bool isU1f2s64(); + inline bool hasU1f2s64(); + inline ::int64_t getU1f2s64(); + inline void setU1f2s64( ::int64_t value); + + inline bool isU1f2sp(); + inline bool hasU1f2sp(); + inline ::capnp::Text::Builder getU1f2sp(); + inline void setU1f2sp( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initU1f2sp(unsigned int size); + inline void adoptU1f2sp(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownU1f2sp(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Union1::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Union1::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnion::Union1::Pipeline { +public: + typedef Union1 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnion::Union2::Reader { +public: + typedef Union2 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isU2f0s1() const; + inline bool hasU2f0s1() const; + inline bool getU2f0s1() const; + + inline bool isU2f0s8() const; + inline bool hasU2f0s8() const; + inline ::int8_t getU2f0s8() const; + + inline bool isU2f0s16() const; + inline bool hasU2f0s16() const; + inline ::int16_t getU2f0s16() const; + + inline bool isU2f0s32() const; + inline bool hasU2f0s32() const; + inline ::int32_t getU2f0s32() const; + + inline bool isU2f0s64() const; + inline bool hasU2f0s64() const; + inline ::int64_t getU2f0s64() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Union2::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Union2::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnion::Union2::Builder { +public: + typedef Union2 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isU2f0s1(); + inline bool hasU2f0s1(); + inline bool getU2f0s1(); + inline void setU2f0s1(bool value); + + inline bool isU2f0s8(); + inline bool hasU2f0s8(); + inline ::int8_t getU2f0s8(); + inline void setU2f0s8( ::int8_t value); + + inline bool isU2f0s16(); + inline bool hasU2f0s16(); + inline ::int16_t getU2f0s16(); + inline void setU2f0s16( ::int16_t value); + + inline bool isU2f0s32(); + inline bool hasU2f0s32(); + inline ::int32_t getU2f0s32(); + inline void setU2f0s32( ::int32_t value); + + inline bool isU2f0s64(); + inline bool hasU2f0s64(); + inline ::int64_t getU2f0s64(); + inline void setU2f0s64( ::int64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Union2::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Union2::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnion::Union2::Pipeline { +public: + typedef Union2 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnion::Union3::Reader { +public: + typedef Union3 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isU3f0s1() const; + inline bool hasU3f0s1() const; + inline bool getU3f0s1() const; + + inline bool isU3f0s8() const; + inline bool hasU3f0s8() const; + inline ::int8_t getU3f0s8() const; + + inline bool isU3f0s16() const; + inline bool hasU3f0s16() const; + inline ::int16_t getU3f0s16() const; + + inline bool isU3f0s32() const; + inline bool hasU3f0s32() const; + inline ::int32_t getU3f0s32() const; + + inline bool isU3f0s64() const; + inline bool hasU3f0s64() const; + inline ::int64_t getU3f0s64() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Union3::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Union3::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnion::Union3::Builder { +public: + typedef Union3 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isU3f0s1(); + inline bool hasU3f0s1(); + inline bool getU3f0s1(); + inline void setU3f0s1(bool value); + + inline bool isU3f0s8(); + inline bool hasU3f0s8(); + inline ::int8_t getU3f0s8(); + inline void setU3f0s8( ::int8_t value); + + inline bool isU3f0s16(); + inline bool hasU3f0s16(); + inline ::int16_t getU3f0s16(); + inline void setU3f0s16( ::int16_t value); + + inline bool isU3f0s32(); + inline bool hasU3f0s32(); + inline ::int32_t getU3f0s32(); + inline void setU3f0s32( ::int32_t value); + + inline bool isU3f0s64(); + inline bool hasU3f0s64(); + inline ::int64_t getU3f0s64(); + inline void setU3f0s64( ::int64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnion::Union3::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnion::Union3::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnion::Union3::Pipeline { +public: + typedef Union3 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnnamedUnion::Reader { +public: + typedef TestUnnamedUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool hasBefore() const; + inline ::capnp::Text::Reader getBefore() const; + + inline bool isFoo() const; + inline bool hasFoo() const; + inline ::uint16_t getFoo() const; + + inline bool hasMiddle() const; + inline ::uint16_t getMiddle() const; + + inline bool isBar() const; + inline bool hasBar() const; + inline ::uint32_t getBar() const; + + inline bool hasAfter() const; + inline ::capnp::Text::Reader getAfter() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnnamedUnion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnnamedUnion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnnamedUnion::Builder { +public: + typedef TestUnnamedUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool hasBefore(); + inline ::capnp::Text::Builder getBefore(); + inline void setBefore( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initBefore(unsigned int size); + inline void adoptBefore(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownBefore(); + + inline bool isFoo(); + inline bool hasFoo(); + inline ::uint16_t getFoo(); + inline void setFoo( ::uint16_t value); + + inline bool hasMiddle(); + inline ::uint16_t getMiddle(); + inline void setMiddle( ::uint16_t value); + + inline bool isBar(); + inline bool hasBar(); + inline ::uint32_t getBar(); + inline void setBar( ::uint32_t value); + + inline bool hasAfter(); + inline ::capnp::Text::Builder getAfter(); + inline void setAfter( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initAfter(unsigned int size); + inline void adoptAfter(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownAfter(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnnamedUnion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnnamedUnion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnnamedUnion::Pipeline { +public: + typedef TestUnnamedUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnionInUnion::Reader { +public: + typedef TestUnionInUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasOuter() const; + inline Outer::Reader getOuter() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnionInUnion::Builder { +public: + typedef TestUnionInUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasOuter(); + inline Outer::Builder getOuter(); + inline Outer::Builder initOuter(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnionInUnion::Pipeline { +public: + typedef TestUnionInUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline Outer::Pipeline getOuter() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnionInUnion::Outer::Reader { +public: + typedef Outer Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isInner() const; + inline bool hasInner() const; + inline Inner::Reader getInner() const; + + inline bool isBaz() const; + inline bool hasBaz() const; + inline ::int32_t getBaz() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Outer::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Outer::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnionInUnion::Outer::Builder { +public: + typedef Outer Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isInner(); + inline bool hasInner(); + inline Inner::Builder getInner(); + inline Inner::Builder initInner(); + + inline bool isBaz(); + inline bool hasBaz(); + inline ::int32_t getBaz(); + inline void setBaz( ::int32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Outer::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Outer::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnionInUnion::Outer::Pipeline { +public: + typedef Outer Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnionInUnion::Outer::Inner::Reader { +public: + typedef Inner Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isFoo() const; + inline bool hasFoo() const; + inline ::int32_t getFoo() const; + + inline bool isBar() const; + inline bool hasBar() const; + inline ::int32_t getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Outer::Inner::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Outer::Inner::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnionInUnion::Outer::Inner::Builder { +public: + typedef Inner Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isFoo(); + inline bool hasFoo(); + inline ::int32_t getFoo(); + inline void setFoo( ::int32_t value); + + inline bool isBar(); + inline bool hasBar(); + inline ::int32_t getBar(); + inline void setBar( ::int32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Outer::Inner::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnionInUnion::Outer::Inner::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnionInUnion::Outer::Inner::Pipeline { +public: + typedef Inner Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestGroups::Reader { +public: + typedef TestGroups Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasGroups() const; + inline Groups::Reader getGroups() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestGroups::Builder { +public: + typedef TestGroups Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasGroups(); + inline Groups::Builder getGroups(); + inline Groups::Builder initGroups(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestGroups::Pipeline { +public: + typedef TestGroups Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline Groups::Pipeline getGroups() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestGroups::Groups::Reader { +public: + typedef Groups Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isFoo() const; + inline bool hasFoo() const; + inline Foo::Reader getFoo() const; + + inline bool isBaz() const; + inline bool hasBaz() const; + inline Baz::Reader getBaz() const; + + inline bool isBar() const; + inline bool hasBar() const; + inline Bar::Reader getBar() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestGroups::Groups::Builder { +public: + typedef Groups Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isFoo(); + inline bool hasFoo(); + inline Foo::Builder getFoo(); + inline Foo::Builder initFoo(); + + inline bool isBaz(); + inline bool hasBaz(); + inline Baz::Builder getBaz(); + inline Baz::Builder initBaz(); + + inline bool isBar(); + inline bool hasBar(); + inline Bar::Builder getBar(); + inline Bar::Builder initBar(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestGroups::Groups::Pipeline { +public: + typedef Groups Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestGroups::Groups::Foo::Reader { +public: + typedef Foo Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasCorge() const; + inline ::int32_t getCorge() const; + + inline bool hasGrault() const; + inline ::int64_t getGrault() const; + + inline bool hasGarply() const; + inline ::capnp::Text::Reader getGarply() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Foo::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Foo::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestGroups::Groups::Foo::Builder { +public: + typedef Foo Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasCorge(); + inline ::int32_t getCorge(); + inline void setCorge( ::int32_t value); + + inline bool hasGrault(); + inline ::int64_t getGrault(); + inline void setGrault( ::int64_t value); + + inline bool hasGarply(); + inline ::capnp::Text::Builder getGarply(); + inline void setGarply( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGarply(unsigned int size); + inline void adoptGarply(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGarply(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Foo::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Foo::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestGroups::Groups::Foo::Pipeline { +public: + typedef Foo Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestGroups::Groups::Baz::Reader { +public: + typedef Baz Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasCorge() const; + inline ::int32_t getCorge() const; + + inline bool hasGrault() const; + inline ::capnp::Text::Reader getGrault() const; + + inline bool hasGarply() const; + inline ::capnp::Text::Reader getGarply() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Baz::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Baz::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestGroups::Groups::Baz::Builder { +public: + typedef Baz Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasCorge(); + inline ::int32_t getCorge(); + inline void setCorge( ::int32_t value); + + inline bool hasGrault(); + inline ::capnp::Text::Builder getGrault(); + inline void setGrault( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGrault(unsigned int size); + inline void adoptGrault(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGrault(); + + inline bool hasGarply(); + inline ::capnp::Text::Builder getGarply(); + inline void setGarply( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGarply(unsigned int size); + inline void adoptGarply(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGarply(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Baz::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Baz::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestGroups::Groups::Baz::Pipeline { +public: + typedef Baz Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestGroups::Groups::Bar::Reader { +public: + typedef Bar Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasCorge() const; + inline ::int32_t getCorge() const; + + inline bool hasGrault() const; + inline ::capnp::Text::Reader getGrault() const; + + inline bool hasGarply() const; + inline ::int64_t getGarply() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Bar::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Bar::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestGroups::Groups::Bar::Builder { +public: + typedef Bar Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasCorge(); + inline ::int32_t getCorge(); + inline void setCorge( ::int32_t value); + + inline bool hasGrault(); + inline ::capnp::Text::Builder getGrault(); + inline void setGrault( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initGrault(unsigned int size); + inline void adoptGrault(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownGrault(); + + inline bool hasGarply(); + inline ::int64_t getGarply(); + inline void setGarply( ::int64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Bar::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestGroups::Groups::Bar::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestGroups::Groups::Bar::Pipeline { +public: + typedef Bar Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterleavedGroups::Reader { +public: + typedef TestInterleavedGroups Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasGroup1() const; + inline Group1::Reader getGroup1() const; + + inline bool hasGroup2() const; + inline Group2::Reader getGroup2() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterleavedGroups::Builder { +public: + typedef TestInterleavedGroups Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasGroup1(); + inline Group1::Builder getGroup1(); + inline Group1::Builder initGroup1(); + + inline bool hasGroup2(); + inline Group2::Builder getGroup2(); + inline Group2::Builder initGroup2(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterleavedGroups::Pipeline { +public: + typedef TestInterleavedGroups Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline Group1::Pipeline getGroup1() const; + inline Group2::Pipeline getGroup2() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterleavedGroups::Group1::Reader { +public: + typedef Group1 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool hasFoo() const; + inline ::uint32_t getFoo() const; + + inline bool hasBar() const; + inline ::uint64_t getBar() const; + + inline bool isQux() const; + inline bool hasQux() const; + inline ::uint16_t getQux() const; + + inline bool isCorge() const; + inline bool hasCorge() const; + inline Corge::Reader getCorge() const; + + inline bool hasWaldo() const; + inline ::capnp::Text::Reader getWaldo() const; + + inline bool isFred() const; + inline bool hasFred() const; + inline ::capnp::Text::Reader getFred() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group1::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group1::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterleavedGroups::Group1::Builder { +public: + typedef Group1 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool hasFoo(); + inline ::uint32_t getFoo(); + inline void setFoo( ::uint32_t value); + + inline bool hasBar(); + inline ::uint64_t getBar(); + inline void setBar( ::uint64_t value); + + inline bool isQux(); + inline bool hasQux(); + inline ::uint16_t getQux(); + inline void setQux( ::uint16_t value); + + inline bool isCorge(); + inline bool hasCorge(); + inline Corge::Builder getCorge(); + inline Corge::Builder initCorge(); + + inline bool hasWaldo(); + inline ::capnp::Text::Builder getWaldo(); + inline void setWaldo( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initWaldo(unsigned int size); + inline void adoptWaldo(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownWaldo(); + + inline bool isFred(); + inline bool hasFred(); + inline ::capnp::Text::Builder getFred(); + inline void setFred( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFred(unsigned int size); + inline void adoptFred(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFred(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group1::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group1::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterleavedGroups::Group1::Pipeline { +public: + typedef Group1 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterleavedGroups::Group1::Corge::Reader { +public: + typedef Corge Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasGrault() const; + inline ::uint64_t getGrault() const; + + inline bool hasGarply() const; + inline ::uint16_t getGarply() const; + + inline bool hasPlugh() const; + inline ::capnp::Text::Reader getPlugh() const; + + inline bool hasXyzzy() const; + inline ::capnp::Text::Reader getXyzzy() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group1::Corge::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group1::Corge::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterleavedGroups::Group1::Corge::Builder { +public: + typedef Corge Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasGrault(); + inline ::uint64_t getGrault(); + inline void setGrault( ::uint64_t value); + + inline bool hasGarply(); + inline ::uint16_t getGarply(); + inline void setGarply( ::uint16_t value); + + inline bool hasPlugh(); + inline ::capnp::Text::Builder getPlugh(); + inline void setPlugh( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPlugh(unsigned int size); + inline void adoptPlugh(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPlugh(); + + inline bool hasXyzzy(); + inline ::capnp::Text::Builder getXyzzy(); + inline void setXyzzy( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initXyzzy(unsigned int size); + inline void adoptXyzzy(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownXyzzy(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group1::Corge::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group1::Corge::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterleavedGroups::Group1::Corge::Pipeline { +public: + typedef Corge Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterleavedGroups::Group2::Reader { +public: + typedef Group2 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool hasFoo() const; + inline ::uint32_t getFoo() const; + + inline bool hasBar() const; + inline ::uint64_t getBar() const; + + inline bool isQux() const; + inline bool hasQux() const; + inline ::uint16_t getQux() const; + + inline bool isCorge() const; + inline bool hasCorge() const; + inline Corge::Reader getCorge() const; + + inline bool hasWaldo() const; + inline ::capnp::Text::Reader getWaldo() const; + + inline bool isFred() const; + inline bool hasFred() const; + inline ::capnp::Text::Reader getFred() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group2::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group2::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterleavedGroups::Group2::Builder { +public: + typedef Group2 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool hasFoo(); + inline ::uint32_t getFoo(); + inline void setFoo( ::uint32_t value); + + inline bool hasBar(); + inline ::uint64_t getBar(); + inline void setBar( ::uint64_t value); + + inline bool isQux(); + inline bool hasQux(); + inline ::uint16_t getQux(); + inline void setQux( ::uint16_t value); + + inline bool isCorge(); + inline bool hasCorge(); + inline Corge::Builder getCorge(); + inline Corge::Builder initCorge(); + + inline bool hasWaldo(); + inline ::capnp::Text::Builder getWaldo(); + inline void setWaldo( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initWaldo(unsigned int size); + inline void adoptWaldo(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownWaldo(); + + inline bool isFred(); + inline bool hasFred(); + inline ::capnp::Text::Builder getFred(); + inline void setFred( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initFred(unsigned int size); + inline void adoptFred(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownFred(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group2::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group2::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterleavedGroups::Group2::Pipeline { +public: + typedef Group2 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterleavedGroups::Group2::Corge::Reader { +public: + typedef Corge Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasGrault() const; + inline ::uint64_t getGrault() const; + + inline bool hasGarply() const; + inline ::uint16_t getGarply() const; + + inline bool hasPlugh() const; + inline ::capnp::Text::Reader getPlugh() const; + + inline bool hasXyzzy() const; + inline ::capnp::Text::Reader getXyzzy() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group2::Corge::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group2::Corge::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterleavedGroups::Group2::Corge::Builder { +public: + typedef Corge Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasGrault(); + inline ::uint64_t getGrault(); + inline void setGrault( ::uint64_t value); + + inline bool hasGarply(); + inline ::uint16_t getGarply(); + inline void setGarply( ::uint16_t value); + + inline bool hasPlugh(); + inline ::capnp::Text::Builder getPlugh(); + inline void setPlugh( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPlugh(unsigned int size); + inline void adoptPlugh(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPlugh(); + + inline bool hasXyzzy(); + inline ::capnp::Text::Builder getXyzzy(); + inline void setXyzzy( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initXyzzy(unsigned int size); + inline void adoptXyzzy(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownXyzzy(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group2::Corge::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterleavedGroups::Group2::Corge::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterleavedGroups::Group2::Corge::Pipeline { +public: + typedef Corge Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUnionDefaults::Reader { +public: + typedef TestUnionDefaults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasS16s8s64s8Set() const; + inline ::capnproto_test::capnp::test::TestUnion::Reader getS16s8s64s8Set() const; + + inline bool hasS0sps1s32Set() const; + inline ::capnproto_test::capnp::test::TestUnion::Reader getS0sps1s32Set() const; + + inline bool hasUnnamed1() const; + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Reader getUnnamed1() const; + + inline bool hasUnnamed2() const; + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Reader getUnnamed2() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnionDefaults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnionDefaults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUnionDefaults::Builder { +public: + typedef TestUnionDefaults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasS16s8s64s8Set(); + inline ::capnproto_test::capnp::test::TestUnion::Builder getS16s8s64s8Set(); + inline void setS16s8s64s8Set( ::capnproto_test::capnp::test::TestUnion::Reader value); + inline ::capnproto_test::capnp::test::TestUnion::Builder initS16s8s64s8Set(); + inline void adoptS16s8s64s8Set(::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion> disownS16s8s64s8Set(); + + inline bool hasS0sps1s32Set(); + inline ::capnproto_test::capnp::test::TestUnion::Builder getS0sps1s32Set(); + inline void setS0sps1s32Set( ::capnproto_test::capnp::test::TestUnion::Reader value); + inline ::capnproto_test::capnp::test::TestUnion::Builder initS0sps1s32Set(); + inline void adoptS0sps1s32Set(::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion> disownS0sps1s32Set(); + + inline bool hasUnnamed1(); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder getUnnamed1(); + inline void setUnnamed1( ::capnproto_test::capnp::test::TestUnnamedUnion::Reader value); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder initUnnamed1(); + inline void adoptUnnamed1(::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion> disownUnnamed1(); + + inline bool hasUnnamed2(); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder getUnnamed2(); + inline void setUnnamed2( ::capnproto_test::capnp::test::TestUnnamedUnion::Reader value); + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder initUnnamed2(); + inline void adoptUnnamed2(::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion> disownUnnamed2(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUnionDefaults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUnionDefaults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUnionDefaults::Pipeline { +public: + typedef TestUnionDefaults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestUnion::Pipeline getS16s8s64s8Set() const; + inline ::capnproto_test::capnp::test::TestUnion::Pipeline getS0sps1s32Set() const; + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline getUnnamed1() const; + inline ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline getUnnamed2() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestNestedTypes::Reader { +public: + typedef TestNestedTypes Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasNestedStruct() const; + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Reader getNestedStruct() const; + + inline bool hasOuterNestedEnum() const; + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum() const; + + inline bool hasInnerNestedEnum() const; + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestNestedTypes::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestNestedTypes::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestNestedTypes::Builder { +public: + typedef TestNestedTypes Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasNestedStruct(); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Builder getNestedStruct(); + inline void setNestedStruct( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Reader value); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Builder initNestedStruct(); + inline void adoptNestedStruct(::capnp::Orphan< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct> disownNestedStruct(); + + inline bool hasOuterNestedEnum(); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum(); + inline void setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value); + + inline bool hasInnerNestedEnum(); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum(); + inline void setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestNestedTypes::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestNestedTypes::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestNestedTypes::Pipeline { +public: + typedef TestNestedTypes Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Pipeline getNestedStruct() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestNestedTypes::NestedStruct::Reader { +public: + typedef NestedStruct Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasOuterNestedEnum() const; + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum() const; + + inline bool hasInnerNestedEnum() const; + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestNestedTypes::NestedStruct::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestNestedTypes::NestedStruct::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestNestedTypes::NestedStruct::Builder { +public: + typedef NestedStruct Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasOuterNestedEnum(); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum(); + inline void setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value); + + inline bool hasInnerNestedEnum(); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum(); + inline void setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestNestedTypes::NestedStruct::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestNestedTypes::NestedStruct::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestNestedTypes::NestedStruct::Pipeline { +public: + typedef NestedStruct Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestUsing::Reader { +public: + typedef TestUsing Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasInnerNestedEnum() const; + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum() const; + + inline bool hasOuterNestedEnum() const; + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUsing::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUsing::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestUsing::Builder { +public: + typedef TestUsing Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasInnerNestedEnum(); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum getInnerNestedEnum(); + inline void setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value); + + inline bool hasOuterNestedEnum(); + inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum getOuterNestedEnum(); + inline void setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestUsing::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestUsing::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestUsing::Pipeline { +public: + typedef TestUsing Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Reader { +public: + typedef TestLists Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasList0() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>::Reader getList0() const; + + inline bool hasList1() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>::Reader getList1() const; + + inline bool hasList8() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>::Reader getList8() const; + + inline bool hasList16() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>::Reader getList16() const; + + inline bool hasList32() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>::Reader getList32() const; + + inline bool hasList64() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>::Reader getList64() const; + + inline bool hasListP() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>::Reader getListP() const; + + inline bool hasInt32ListList() const; + inline ::capnp::List< ::capnp::List< ::int32_t>>::Reader getInt32ListList() const; + + inline bool hasTextListList() const; + inline ::capnp::List< ::capnp::List< ::capnp::Text>>::Reader getTextListList() const; + + inline bool hasStructListList() const; + inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::Reader getStructListList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Builder { +public: + typedef TestLists Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasList0(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>::Builder getList0(); + inline void setList0( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>::Builder initList0(unsigned int size); + inline void adoptList0(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>> disownList0(); + + inline bool hasList1(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>::Builder getList1(); + inline void setList1( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>::Builder initList1(unsigned int size); + inline void adoptList1(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>> disownList1(); + + inline bool hasList8(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>::Builder getList8(); + inline void setList8( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>::Builder initList8(unsigned int size); + inline void adoptList8(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>> disownList8(); + + inline bool hasList16(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>::Builder getList16(); + inline void setList16( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>::Builder initList16(unsigned int size); + inline void adoptList16(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>> disownList16(); + + inline bool hasList32(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>::Builder getList32(); + inline void setList32( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>::Builder initList32(unsigned int size); + inline void adoptList32(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>> disownList32(); + + inline bool hasList64(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>::Builder getList64(); + inline void setList64( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>::Builder initList64(unsigned int size); + inline void adoptList64(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>> disownList64(); + + inline bool hasListP(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>::Builder getListP(); + inline void setListP( ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>::Reader value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>::Builder initListP(unsigned int size); + inline void adoptListP(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>> disownListP(); + + inline bool hasInt32ListList(); + inline ::capnp::List< ::capnp::List< ::int32_t>>::Builder getInt32ListList(); + inline void setInt32ListList( ::capnp::List< ::capnp::List< ::int32_t>>::Reader value); + inline void setInt32ListList(std::initializer_list< ::capnp::List< ::int32_t>::Reader> value); + inline ::capnp::List< ::capnp::List< ::int32_t>>::Builder initInt32ListList(unsigned int size); + inline void adoptInt32ListList(::capnp::Orphan< ::capnp::List< ::capnp::List< ::int32_t>>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::int32_t>>> disownInt32ListList(); + + inline bool hasTextListList(); + inline ::capnp::List< ::capnp::List< ::capnp::Text>>::Builder getTextListList(); + inline void setTextListList( ::capnp::List< ::capnp::List< ::capnp::Text>>::Reader value); + inline void setTextListList(std::initializer_list< ::capnp::List< ::capnp::Text>::Reader> value); + inline ::capnp::List< ::capnp::List< ::capnp::Text>>::Builder initTextListList(unsigned int size); + inline void adoptTextListList(::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text>>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text>>> disownTextListList(); + + inline bool hasStructListList(); + inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::Builder getStructListList(); + inline void setStructListList( ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::Reader value); + inline void setStructListList(std::initializer_list< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader> value); + inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::Builder initStructListList(unsigned int size); + inline void adoptStructListList(::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>> disownStructListList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Pipeline { +public: + typedef TestLists Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct0::Reader { +public: + typedef Struct0 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::capnp::Void getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct0::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct0::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct0::Builder { +public: + typedef Struct0 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::capnp::Void getF(); + inline void setF( ::capnp::Void value = ::capnp::VOID); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct0::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct0::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct0::Pipeline { +public: + typedef Struct0 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct1::Reader { +public: + typedef Struct1 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline bool getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct1::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct1::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct1::Builder { +public: + typedef Struct1 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline bool getF(); + inline void setF(bool value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct1::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct1::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct1::Pipeline { +public: + typedef Struct1 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct8::Reader { +public: + typedef Struct8 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::uint8_t getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct8::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct8::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct8::Builder { +public: + typedef Struct8 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::uint8_t getF(); + inline void setF( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct8::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct8::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct8::Pipeline { +public: + typedef Struct8 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct16::Reader { +public: + typedef Struct16 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::uint16_t getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct16::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct16::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct16::Builder { +public: + typedef Struct16 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::uint16_t getF(); + inline void setF( ::uint16_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct16::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct16::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct16::Pipeline { +public: + typedef Struct16 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct32::Reader { +public: + typedef Struct32 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::uint32_t getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct32::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct32::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct32::Builder { +public: + typedef Struct32 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::uint32_t getF(); + inline void setF( ::uint32_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct32::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct32::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct32::Pipeline { +public: + typedef Struct32 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct64::Reader { +public: + typedef Struct64 Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::uint64_t getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct64::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct64::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct64::Builder { +public: + typedef Struct64 Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::uint64_t getF(); + inline void setF( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct64::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct64::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct64::Pipeline { +public: + typedef Struct64 Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::StructP::Reader { +public: + typedef StructP Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::capnp::Text::Reader getF() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::StructP::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::StructP::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::StructP::Builder { +public: + typedef StructP Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::capnp::Text::Builder getF(); + inline void setF( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initF(unsigned int size); + inline void adoptF(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownF(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::StructP::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::StructP::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::StructP::Pipeline { +public: + typedef StructP Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct0c::Reader { +public: + typedef Struct0c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::capnp::Void getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct0c::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct0c::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct0c::Builder { +public: + typedef Struct0c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::capnp::Void getF(); + inline void setF( ::capnp::Void value = ::capnp::VOID); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct0c::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct0c::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct0c::Pipeline { +public: + typedef Struct0c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct1c::Reader { +public: + typedef Struct1c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline bool getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct1c::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct1c::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct1c::Builder { +public: + typedef Struct1c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline bool getF(); + inline void setF(bool value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct1c::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct1c::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct1c::Pipeline { +public: + typedef Struct1c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct8c::Reader { +public: + typedef Struct8c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::uint8_t getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct8c::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct8c::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct8c::Builder { +public: + typedef Struct8c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::uint8_t getF(); + inline void setF( ::uint8_t value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct8c::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct8c::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct8c::Pipeline { +public: + typedef Struct8c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct16c::Reader { +public: + typedef Struct16c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::uint16_t getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct16c::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct16c::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct16c::Builder { +public: + typedef Struct16c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::uint16_t getF(); + inline void setF( ::uint16_t value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct16c::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct16c::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct16c::Pipeline { +public: + typedef Struct16c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct32c::Reader { +public: + typedef Struct32c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::uint32_t getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct32c::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct32c::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct32c::Builder { +public: + typedef Struct32c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::uint32_t getF(); + inline void setF( ::uint32_t value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct32c::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct32c::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct32c::Pipeline { +public: + typedef Struct32c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::Struct64c::Reader { +public: + typedef Struct64c Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::uint64_t getF() const; + + inline bool hasPad() const; + inline ::capnp::Text::Reader getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct64c::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct64c::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::Struct64c::Builder { +public: + typedef Struct64c Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::uint64_t getF(); + inline void setF( ::uint64_t value); + + inline bool hasPad(); + inline ::capnp::Text::Builder getPad(); + inline void setPad( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initPad(unsigned int size); + inline void adoptPad(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownPad(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::Struct64c::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::Struct64c::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::Struct64c::Pipeline { +public: + typedef Struct64c Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLists::StructPc::Reader { +public: + typedef StructPc Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasF() const; + inline ::capnp::Text::Reader getF() const; + + inline bool hasPad() const; + inline ::uint64_t getPad() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::StructPc::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::StructPc::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLists::StructPc::Builder { +public: + typedef StructPc Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasF(); + inline ::capnp::Text::Builder getF(); + inline void setF( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initF(unsigned int size); + inline void adoptF(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownF(); + + inline bool hasPad(); + inline ::uint64_t getPad(); + inline void setPad( ::uint64_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLists::StructPc::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLists::StructPc::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLists::StructPc::Pipeline { +public: + typedef StructPc Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestFieldZeroIsBit::Reader { +public: + typedef TestFieldZeroIsBit Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasBit() const; + inline bool getBit() const; + + inline bool hasSecondBit() const; + inline bool getSecondBit() const; + + inline bool hasThirdField() const; + inline ::uint8_t getThirdField() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestFieldZeroIsBit::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestFieldZeroIsBit::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestFieldZeroIsBit::Builder { +public: + typedef TestFieldZeroIsBit Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasBit(); + inline bool getBit(); + inline void setBit(bool value); + + inline bool hasSecondBit(); + inline bool getSecondBit(); + inline void setSecondBit(bool value); + + inline bool hasThirdField(); + inline ::uint8_t getThirdField(); + inline void setThirdField( ::uint8_t value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestFieldZeroIsBit::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestFieldZeroIsBit::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestFieldZeroIsBit::Pipeline { +public: + typedef TestFieldZeroIsBit Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestListDefaults::Reader { +public: + typedef TestListDefaults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasLists() const; + inline ::capnproto_test::capnp::test::TestLists::Reader getLists() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestListDefaults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestListDefaults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestListDefaults::Builder { +public: + typedef TestListDefaults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasLists(); + inline ::capnproto_test::capnp::test::TestLists::Builder getLists(); + inline void setLists( ::capnproto_test::capnp::test::TestLists::Reader value); + inline ::capnproto_test::capnp::test::TestLists::Builder initLists(); + inline void adoptLists(::capnp::Orphan< ::capnproto_test::capnp::test::TestLists>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestLists> disownLists(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestListDefaults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestListDefaults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestListDefaults::Pipeline { +public: + typedef TestListDefaults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestLists::Pipeline getLists() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLateUnion::Reader { +public: + typedef TestLateUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasFoo() const; + inline ::int32_t getFoo() const; + + inline bool hasBar() const; + inline ::capnp::Text::Reader getBar() const; + + inline bool hasBaz() const; + inline ::int16_t getBaz() const; + + inline bool hasTheUnion() const; + inline TheUnion::Reader getTheUnion() const; + + inline bool hasAnotherUnion() const; + inline AnotherUnion::Reader getAnotherUnion() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLateUnion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLateUnion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLateUnion::Builder { +public: + typedef TestLateUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasFoo(); + inline ::int32_t getFoo(); + inline void setFoo( ::int32_t value); + + inline bool hasBar(); + inline ::capnp::Text::Builder getBar(); + inline void setBar( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initBar(unsigned int size); + inline void adoptBar(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownBar(); + + inline bool hasBaz(); + inline ::int16_t getBaz(); + inline void setBaz( ::int16_t value); + + inline bool hasTheUnion(); + inline TheUnion::Builder getTheUnion(); + inline TheUnion::Builder initTheUnion(); + + inline bool hasAnotherUnion(); + inline AnotherUnion::Builder getAnotherUnion(); + inline AnotherUnion::Builder initAnotherUnion(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLateUnion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLateUnion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLateUnion::Pipeline { +public: + typedef TestLateUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline TheUnion::Pipeline getTheUnion() const; + inline AnotherUnion::Pipeline getAnotherUnion() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLateUnion::TheUnion::Reader { +public: + typedef TheUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isQux() const; + inline bool hasQux() const; + inline ::capnp::Text::Reader getQux() const; + + inline bool isCorge() const; + inline bool hasCorge() const; + inline ::capnp::List< ::int32_t>::Reader getCorge() const; + + inline bool isGrault() const; + inline bool hasGrault() const; + inline float getGrault() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLateUnion::TheUnion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLateUnion::TheUnion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLateUnion::TheUnion::Builder { +public: + typedef TheUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isQux(); + inline bool hasQux(); + inline ::capnp::Text::Builder getQux(); + inline void setQux( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQux(unsigned int size); + inline void adoptQux(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQux(); + + inline bool isCorge(); + inline bool hasCorge(); + inline ::capnp::List< ::int32_t>::Builder getCorge(); + inline void setCorge( ::capnp::List< ::int32_t>::Reader value); + inline void setCorge(std::initializer_list< ::int32_t> value); + inline ::capnp::List< ::int32_t>::Builder initCorge(unsigned int size); + inline void adoptCorge(::capnp::Orphan< ::capnp::List< ::int32_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t>> disownCorge(); + + inline bool isGrault(); + inline bool hasGrault(); + inline float getGrault(); + inline void setGrault(float value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLateUnion::TheUnion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLateUnion::TheUnion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLateUnion::TheUnion::Pipeline { +public: + typedef TheUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestLateUnion::AnotherUnion::Reader { +public: + typedef AnotherUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isQux() const; + inline bool hasQux() const; + inline ::capnp::Text::Reader getQux() const; + + inline bool isCorge() const; + inline bool hasCorge() const; + inline ::capnp::List< ::int32_t>::Reader getCorge() const; + + inline bool isGrault() const; + inline bool hasGrault() const; + inline float getGrault() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLateUnion::AnotherUnion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLateUnion::AnotherUnion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestLateUnion::AnotherUnion::Builder { +public: + typedef AnotherUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isQux(); + inline bool hasQux(); + inline ::capnp::Text::Builder getQux(); + inline void setQux( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initQux(unsigned int size); + inline void adoptQux(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownQux(); + + inline bool isCorge(); + inline bool hasCorge(); + inline ::capnp::List< ::int32_t>::Builder getCorge(); + inline void setCorge( ::capnp::List< ::int32_t>::Reader value); + inline void setCorge(std::initializer_list< ::int32_t> value); + inline ::capnp::List< ::int32_t>::Builder initCorge(unsigned int size); + inline void adoptCorge(::capnp::Orphan< ::capnp::List< ::int32_t>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::int32_t>> disownCorge(); + + inline bool isGrault(); + inline bool hasGrault(); + inline float getGrault(); + inline void setGrault(float value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestLateUnion::AnotherUnion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestLateUnion::AnotherUnion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestLateUnion::AnotherUnion::Pipeline { +public: + typedef AnotherUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestOldVersion::Reader { +public: + typedef TestOldVersion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasOld1() const; + inline ::int64_t getOld1() const; + + inline bool hasOld2() const; + inline ::capnp::Text::Reader getOld2() const; + + inline bool hasOld3() const; + inline ::capnproto_test::capnp::test::TestOldVersion::Reader getOld3() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestOldVersion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestOldVersion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestOldVersion::Builder { +public: + typedef TestOldVersion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasOld1(); + inline ::int64_t getOld1(); + inline void setOld1( ::int64_t value); + + inline bool hasOld2(); + inline ::capnp::Text::Builder getOld2(); + inline void setOld2( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOld2(unsigned int size); + inline void adoptOld2(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOld2(); + + inline bool hasOld3(); + inline ::capnproto_test::capnp::test::TestOldVersion::Builder getOld3(); + inline void setOld3( ::capnproto_test::capnp::test::TestOldVersion::Reader value); + inline ::capnproto_test::capnp::test::TestOldVersion::Builder initOld3(); + inline void adoptOld3(::capnp::Orphan< ::capnproto_test::capnp::test::TestOldVersion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestOldVersion> disownOld3(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestOldVersion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestOldVersion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestOldVersion::Pipeline { +public: + typedef TestOldVersion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestOldVersion::Pipeline getOld3() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestNewVersion::Reader { +public: + typedef TestNewVersion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasOld1() const; + inline ::int64_t getOld1() const; + + inline bool hasOld2() const; + inline ::capnp::Text::Reader getOld2() const; + + inline bool hasOld3() const; + inline ::capnproto_test::capnp::test::TestNewVersion::Reader getOld3() const; + + inline bool hasNew1() const; + inline ::int64_t getNew1() const; + + inline bool hasNew2() const; + inline ::capnp::Text::Reader getNew2() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestNewVersion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestNewVersion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestNewVersion::Builder { +public: + typedef TestNewVersion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasOld1(); + inline ::int64_t getOld1(); + inline void setOld1( ::int64_t value); + + inline bool hasOld2(); + inline ::capnp::Text::Builder getOld2(); + inline void setOld2( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initOld2(unsigned int size); + inline void adoptOld2(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownOld2(); + + inline bool hasOld3(); + inline ::capnproto_test::capnp::test::TestNewVersion::Builder getOld3(); + inline void setOld3( ::capnproto_test::capnp::test::TestNewVersion::Reader value); + inline ::capnproto_test::capnp::test::TestNewVersion::Builder initOld3(); + inline void adoptOld3(::capnp::Orphan< ::capnproto_test::capnp::test::TestNewVersion>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestNewVersion> disownOld3(); + + inline bool hasNew1(); + inline ::int64_t getNew1(); + inline void setNew1( ::int64_t value); + + inline bool hasNew2(); + inline ::capnp::Text::Builder getNew2(); + inline void setNew2( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initNew2(unsigned int size); + inline void adoptNew2(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownNew2(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestNewVersion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestNewVersion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestNewVersion::Pipeline { +public: + typedef TestNewVersion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestNewVersion::Pipeline getOld3() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestStructUnion::Reader { +public: + typedef TestStructUnion Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasUn() const; + inline Un::Reader getUn() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestStructUnion::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestStructUnion::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestStructUnion::Builder { +public: + typedef TestStructUnion Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasUn(); + inline Un::Builder getUn(); + inline Un::Builder initUn(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestStructUnion::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestStructUnion::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestStructUnion::Pipeline { +public: + typedef TestStructUnion Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline Un::Pipeline getUn() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestStructUnion::Un::Reader { +public: + typedef Un Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline Which which() const; + inline bool isAllTypes() const; + inline bool hasAllTypes() const; + inline ::capnproto_test::capnp::test::TestAllTypes::Reader getAllTypes() const; + + inline bool isObject() const; + inline bool hasObject() const; + inline ::capnproto_test::capnp::test::TestObject::Reader getObject() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestStructUnion::Un::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestStructUnion::Un::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestStructUnion::Un::Builder { +public: + typedef Un Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline Which which(); + inline bool isAllTypes(); + inline bool hasAllTypes(); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder getAllTypes(); + inline void setAllTypes( ::capnproto_test::capnp::test::TestAllTypes::Reader value); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder initAllTypes(); + inline void adoptAllTypes(::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> disownAllTypes(); + + inline bool isObject(); + inline bool hasObject(); + inline ::capnproto_test::capnp::test::TestObject::Builder getObject(); + inline void setObject( ::capnproto_test::capnp::test::TestObject::Reader value); + inline ::capnproto_test::capnp::test::TestObject::Builder initObject(); + inline void adoptObject(::capnp::Orphan< ::capnproto_test::capnp::test::TestObject>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestObject> disownObject(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestStructUnion::Un::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestStructUnion::Un::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestStructUnion::Un::Pipeline { +public: + typedef Un Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestEmptyStruct::Reader { +public: + typedef TestEmptyStruct Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestEmptyStruct::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestEmptyStruct::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestEmptyStruct::Builder { +public: + typedef TestEmptyStruct Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestEmptyStruct::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestEmptyStruct::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestEmptyStruct::Pipeline { +public: + typedef TestEmptyStruct Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestConstants::Reader { +public: + typedef TestConstants Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestConstants::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestConstants::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestConstants::Builder { +public: + typedef TestConstants Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestConstants::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestConstants::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestConstants::Pipeline { +public: + typedef TestConstants Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterface::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestInterface Calls; + typedef TestInterface Reads; + + inline explicit Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} + inline explicit Client(::kj::Own&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} + template ()>> + inline Client(::kj::Own&& server, + const ::kj::EventLoop& loop = ::kj::EventLoop::current()) + : ::capnp::Capability::Client(::kj::mv(server), loop) {} + + ::capnp::Request fooRequest( + unsigned int firstSegmentWordSize = 0) const; + ::capnp::Request barRequest( + unsigned int firstSegmentWordSize = 0) const; + ::capnp::Request bazRequest( + unsigned int firstSegmentWordSize = 0) const; + +protected: + Client() = default; +}; + +class TestInterface::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestInterface Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) + override; + +protected: + // Implementation should implement one of each method (normal or advanced). + virtual ::kj::Promise foo( + TestInterface::FooParams::Reader params, + TestInterface::FooResults::Builder result); + virtual ::kj::Promise fooAdvanced( + ::capnp::CallContext context); + virtual ::kj::Promise bar( + TestInterface::BarParams::Reader params, + TestInterface::BarResults::Builder result); + virtual ::kj::Promise barAdvanced( + ::capnp::CallContext context); + virtual ::kj::Promise baz( + TestInterface::BazParams::Reader params, + TestInterface::BazResults::Builder result); + virtual ::kj::Promise bazAdvanced( + ::capnp::CallContext context); + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context); +}; + +class TestInterface::FooParams::Reader { +public: + typedef FooParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasI() const; + inline ::uint32_t getI() const; + + inline bool hasJ() const; + inline bool getJ() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::FooParams::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::FooParams::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterface::FooParams::Builder { +public: + typedef FooParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasI(); + inline ::uint32_t getI(); + inline void setI( ::uint32_t value); + + inline bool hasJ(); + inline bool getJ(); + inline void setJ(bool value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::FooParams::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::FooParams::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterface::FooParams::Pipeline { +public: + typedef FooParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterface::FooResults::Reader { +public: + typedef FooResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasX() const; + inline ::capnp::Text::Reader getX() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::FooResults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::FooResults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterface::FooResults::Builder { +public: + typedef FooResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasX(); + inline ::capnp::Text::Builder getX(); + inline void setX( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initX(unsigned int size); + inline void adoptX(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownX(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::FooResults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::FooResults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterface::FooResults::Pipeline { +public: + typedef FooResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterface::BarParams::Reader { +public: + typedef BarParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::BarParams::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::BarParams::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterface::BarParams::Builder { +public: + typedef BarParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::BarParams::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::BarParams::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterface::BarParams::Pipeline { +public: + typedef BarParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterface::BarResults::Reader { +public: + typedef BarResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::BarResults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::BarResults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterface::BarResults::Builder { +public: + typedef BarResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::BarResults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::BarResults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterface::BarResults::Pipeline { +public: + typedef BarResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterface::BazParams::Reader { +public: + typedef BazParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasS() const; + inline ::capnproto_test::capnp::test::TestAllTypes::Reader getS() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::BazParams::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::BazParams::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterface::BazParams::Builder { +public: + typedef BazParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasS(); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder getS(); + inline void setS( ::capnproto_test::capnp::test::TestAllTypes::Reader value); + inline ::capnproto_test::capnp::test::TestAllTypes::Builder initS(); + inline void adoptS(::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> disownS(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::BazParams::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::BazParams::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterface::BazParams::Pipeline { +public: + typedef BazParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline getS() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestInterface::BazResults::Reader { +public: + typedef BazResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::BazResults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::BazResults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestInterface::BazResults::Builder { +public: + typedef BazResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestInterface::BazResults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestInterface::BazResults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestInterface::BazResults::Pipeline { +public: + typedef BazResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestExtends::Client + : public virtual ::capnp::Capability::Client, + public virtual ::capnproto_test::capnp::test::TestInterface::Client { +public: + typedef TestExtends Calls; + typedef TestExtends Reads; + + inline explicit Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} + inline explicit Client(::kj::Own&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} + template ()>> + inline Client(::kj::Own&& server, + const ::kj::EventLoop& loop = ::kj::EventLoop::current()) + : ::capnp::Capability::Client(::kj::mv(server), loop) {} + + ::capnp::Request quxRequest( + unsigned int firstSegmentWordSize = 0) const; + ::capnp::Request< ::capnproto_test::capnp::test::TestAllTypes, TestExtends::CorgeResults> corgeRequest( + unsigned int firstSegmentWordSize = 0) const; + ::capnp::Request graultRequest( + unsigned int firstSegmentWordSize = 0) const; + +protected: + Client() = default; +}; + +class TestExtends::Server + : public virtual ::capnp::Capability::Server, + public virtual ::capnproto_test::capnp::test::TestInterface::Server { +public: + typedef TestExtends Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) + override; + +protected: + // Implementation should implement one of each method (normal or advanced). + virtual ::kj::Promise qux( + TestExtends::QuxParams::Reader params, + TestExtends::QuxResults::Builder result); + virtual ::kj::Promise quxAdvanced( + ::capnp::CallContext context); + virtual ::kj::Promise corge( + ::capnproto_test::capnp::test::TestAllTypes::Reader params, + TestExtends::CorgeResults::Builder result); + virtual ::kj::Promise corgeAdvanced( + ::capnp::CallContext< ::capnproto_test::capnp::test::TestAllTypes, TestExtends::CorgeResults> context); + virtual ::kj::Promise grault( + TestExtends::GraultParams::Reader params, + ::capnproto_test::capnp::test::TestAllTypes::Builder result); + virtual ::kj::Promise graultAdvanced( + ::capnp::CallContext context); + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context); +}; + +class TestExtends::QuxParams::Reader { +public: + typedef QuxParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestExtends::QuxParams::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestExtends::QuxParams::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestExtends::QuxParams::Builder { +public: + typedef QuxParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestExtends::QuxParams::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestExtends::QuxParams::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestExtends::QuxParams::Pipeline { +public: + typedef QuxParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestExtends::QuxResults::Reader { +public: + typedef QuxResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestExtends::QuxResults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestExtends::QuxResults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestExtends::QuxResults::Builder { +public: + typedef QuxResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestExtends::QuxResults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestExtends::QuxResults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestExtends::QuxResults::Pipeline { +public: + typedef QuxResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestExtends::CorgeResults::Reader { +public: + typedef CorgeResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestExtends::CorgeResults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestExtends::CorgeResults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestExtends::CorgeResults::Builder { +public: + typedef CorgeResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestExtends::CorgeResults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestExtends::CorgeResults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestExtends::CorgeResults::Pipeline { +public: + typedef CorgeResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestExtends::GraultParams::Reader { +public: + typedef GraultParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestExtends::GraultParams::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestExtends::GraultParams::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestExtends::GraultParams::Builder { +public: + typedef GraultParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestExtends::GraultParams::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestExtends::GraultParams::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestExtends::GraultParams::Pipeline { +public: + typedef GraultParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestPipeline::Client + : public virtual ::capnp::Capability::Client { +public: + typedef TestPipeline Calls; + typedef TestPipeline Reads; + + inline explicit Client(decltype(nullptr)) + : ::capnp::Capability::Client(nullptr) {} + inline explicit Client(::kj::Own&& hook) + : ::capnp::Capability::Client(::kj::mv(hook)) {} + template ()>> + inline Client(::kj::Own&& server, + const ::kj::EventLoop& loop = ::kj::EventLoop::current()) + : ::capnp::Capability::Client(::kj::mv(server), loop) {} + + ::capnp::Request getCapRequest( + unsigned int firstSegmentWordSize = 0) const; + ::capnp::Request testPointersRequest( + unsigned int firstSegmentWordSize = 0) const; + +protected: + Client() = default; +}; + +class TestPipeline::Server + : public virtual ::capnp::Capability::Server { +public: + typedef TestPipeline Serves; + + ::kj::Promise dispatchCall(uint64_t interfaceId, uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context) + override; + +protected: + // Implementation should implement one of each method (normal or advanced). + virtual ::kj::Promise getCap( + TestPipeline::GetCapParams::Reader params, + TestPipeline::GetCapResults::Builder result); + virtual ::kj::Promise getCapAdvanced( + ::capnp::CallContext context); + virtual ::kj::Promise testPointers( + TestPipeline::TestPointersParams::Reader params, + TestPipeline::TestPointersResults::Builder result); + virtual ::kj::Promise testPointersAdvanced( + ::capnp::CallContext context); + + ::kj::Promise dispatchCallInternal(uint16_t methodId, + ::capnp::CallContext< ::capnp::ObjectPointer, ::capnp::ObjectPointer> context); +}; + +class TestPipeline::Box::Reader { +public: + typedef Box Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasCap() const; + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::Box::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::Box::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestPipeline::Box::Builder { +public: + typedef Box Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasCap(); + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap(const ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::Box::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::Box::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestPipeline::Box::Pipeline { +public: + typedef Box Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestPipeline::GetCapParams::Reader { +public: + typedef GetCapParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasN() const; + inline ::uint32_t getN() const; + + inline bool hasInCap() const; + inline ::capnproto_test::capnp::test::TestInterface::Client getInCap() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::GetCapParams::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::GetCapParams::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestPipeline::GetCapParams::Builder { +public: + typedef GetCapParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasN(); + inline ::uint32_t getN(); + inline void setN( ::uint32_t value); + + inline bool hasInCap(); + inline ::capnproto_test::capnp::test::TestInterface::Client getInCap(); + inline void setInCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setInCap(const ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptInCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownInCap(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::GetCapParams::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::GetCapParams::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestPipeline::GetCapParams::Pipeline { +public: + typedef GetCapParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getInCap() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestPipeline::GetCapResults::Reader { +public: + typedef GetCapResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasS() const; + inline ::capnp::Text::Reader getS() const; + + inline bool hasOutBox() const; + inline ::capnproto_test::capnp::test::TestPipeline::Box::Reader getOutBox() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::GetCapResults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::GetCapResults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestPipeline::GetCapResults::Builder { +public: + typedef GetCapResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasS(); + inline ::capnp::Text::Builder getS(); + inline void setS( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initS(unsigned int size); + inline void adoptS(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownS(); + + inline bool hasOutBox(); + inline ::capnproto_test::capnp::test::TestPipeline::Box::Builder getOutBox(); + inline void setOutBox( ::capnproto_test::capnp::test::TestPipeline::Box::Reader value); + inline ::capnproto_test::capnp::test::TestPipeline::Box::Builder initOutBox(); + inline void adoptOutBox(::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::Box>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::Box> disownOutBox(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::GetCapResults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::GetCapResults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestPipeline::GetCapResults::Pipeline { +public: + typedef GetCapResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestPipeline::Box::Pipeline getOutBox() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestPipeline::TestPointersParams::Reader { +public: + typedef TestPointersParams Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasCap() const; + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; + + inline bool hasObj() const; + inline ::capnp::ObjectPointer::Reader getObj() const; + + inline bool hasList() const; + inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface>::Reader getList() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::TestPointersParams::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::TestPointersParams::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestPipeline::TestPointersParams::Builder { +public: + typedef TestPointersParams Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasCap(); + inline ::capnproto_test::capnp::test::TestInterface::Client getCap(); + inline void setCap( ::capnproto_test::capnp::test::TestInterface::Client&& value); + inline void setCap(const ::capnproto_test::capnp::test::TestInterface::Client& value); + inline void adoptCap(::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value); + inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> disownCap(); + + inline bool hasObj(); + inline ::capnp::ObjectPointer::Builder getObj(); + inline ::capnp::ObjectPointer::Builder initObj(); + + inline bool hasList(); + inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface>::Builder getList(); + inline void setList( ::capnp::List< ::capnproto_test::capnp::test::TestInterface>::Reader value); + inline void setList(std::initializer_list< ::capnproto_test::capnp::test::TestInterface::Client> value); + inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface>::Builder initList(unsigned int size); + inline void adoptList(::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>&& value); + inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>> disownList(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::TestPointersParams::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::TestPointersParams::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestPipeline::TestPointersParams::Pipeline { +public: + typedef TestPointersParams Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + + inline ::capnproto_test::capnp::test::TestInterface::Client getCap() const; +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestPipeline::TestPointersResults::Reader { +public: + typedef TestPointersResults Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::TestPointersResults::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::TestPointersResults::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestPipeline::TestPointersResults::Builder { +public: + typedef TestPointersResults Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestPipeline::TestPointersResults::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestPipeline::TestPointersResults::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestPipeline::TestPointersResults::Pipeline { +public: + typedef TestPointersResults Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestSturdyRefHostId::Reader { +public: + typedef TestSturdyRefHostId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasHost() const; + inline ::capnp::Text::Reader getHost() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestSturdyRefHostId::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestSturdyRefHostId::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestSturdyRefHostId::Builder { +public: + typedef TestSturdyRefHostId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasHost(); + inline ::capnp::Text::Builder getHost(); + inline void setHost( ::capnp::Text::Reader value); + inline ::capnp::Text::Builder initHost(unsigned int size); + inline void adoptHost(::capnp::Orphan< ::capnp::Text>&& value); + inline ::capnp::Orphan< ::capnp::Text> disownHost(); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestSturdyRefHostId::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestSturdyRefHostId::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestSturdyRefHostId::Pipeline { +public: + typedef TestSturdyRefHostId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestSturdyRefObjectId::Reader { +public: + typedef TestSturdyRefObjectId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + + inline bool hasTag() const; + inline ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag getTag() const; + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestSturdyRefObjectId::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestSturdyRefObjectId::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestSturdyRefObjectId::Builder { +public: + typedef TestSturdyRefObjectId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + + inline bool hasTag(); + inline ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag getTag(); + inline void setTag( ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag value); + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestSturdyRefObjectId::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestSturdyRefObjectId::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestSturdyRefObjectId::Pipeline { +public: + typedef TestSturdyRefObjectId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestProvisionId::Reader { +public: + typedef TestProvisionId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestProvisionId::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestProvisionId::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestProvisionId::Builder { +public: + typedef TestProvisionId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestProvisionId::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestProvisionId::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestProvisionId::Pipeline { +public: + typedef TestProvisionId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestRecipientId::Reader { +public: + typedef TestRecipientId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestRecipientId::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestRecipientId::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestRecipientId::Builder { +public: + typedef TestRecipientId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestRecipientId::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestRecipientId::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestRecipientId::Pipeline { +public: + typedef TestRecipientId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestThirdPartyCapId::Reader { +public: + typedef TestThirdPartyCapId Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestThirdPartyCapId::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestThirdPartyCapId::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestThirdPartyCapId::Builder { +public: + typedef TestThirdPartyCapId Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestThirdPartyCapId::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestThirdPartyCapId::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestThirdPartyCapId::Pipeline { +public: + typedef TestThirdPartyCapId Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +class TestJoinAnswer::Reader { +public: + typedef TestJoinAnswer Reads; + + Reader() = default; + inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} + + inline size_t totalSizeInWords() const { + return _reader.totalSize() / ::capnp::WORDS; + } + +private: + ::capnp::_::StructReader _reader; + template + friend struct ::capnp::ToDynamic_; + template + friend struct ::capnp::_::PointerHelpers; + template + friend struct ::capnp::List; + friend class ::capnp::MessageBuilder; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestJoinAnswer::Reader reader); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestJoinAnswer::Reader reader) { + return ::capnp::_::structString(reader._reader); +} + +class TestJoinAnswer::Builder { +public: + typedef TestJoinAnswer Builds; + + Builder() = delete; // Deleted to discourage incorrect usage. + // You can explicitly initialize to nullptr instead. + inline Builder(decltype(nullptr)) {} + inline explicit Builder(::capnp::_::StructBuilder base): _builder(base) {} + inline operator Reader() const { return Reader(_builder.asReader()); } + inline Reader asReader() const { return *this; } + + inline size_t totalSizeInWords() { return asReader().totalSizeInWords(); } + +private: + ::capnp::_::StructBuilder _builder; + template + friend struct ::capnp::ToDynamic_; + friend class ::capnp::Orphanage; + friend ::kj::StringTree KJ_STRINGIFY(TestJoinAnswer::Builder builder); +}; + +inline ::kj::StringTree KJ_STRINGIFY(TestJoinAnswer::Builder builder) { + return ::capnp::_::structString(builder._builder.asReader()); +} + +class TestJoinAnswer::Pipeline { +public: + typedef TestJoinAnswer Pipelines; + + inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} + inline explicit Pipeline(::capnp::ObjectPointer::Pipeline&& typeless) + : _typeless(kj::mv(typeless)) {} + +private: + ::capnp::ObjectPointer::Pipeline _typeless; + template + friend struct ::capnp::ToDynamic_; +}; + +// ======================================================================================= + +inline bool TestAllTypes::Reader::hasVoidField() const { + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasVoidField() { + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestAllTypes::Reader::getVoidField() const { + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestAllTypes::Builder::getVoidField() { + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setVoidField( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasBoolField() const { + return _reader.hasDataField(0 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasBoolField() { + return _builder.hasDataField(0 * ::capnp::ELEMENTS); +} +inline bool TestAllTypes::Reader::getBoolField() const { + return _reader.getDataField( + 0 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::getBoolField() { + return _builder.getDataField( + 0 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setBoolField(bool value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasInt8Field() const { + return _reader.hasDataField< ::int8_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasInt8Field() { + return _builder.hasDataField< ::int8_t>(1 * ::capnp::ELEMENTS); +} +inline ::int8_t TestAllTypes::Reader::getInt8Field() const { + return _reader.getDataField< ::int8_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::int8_t TestAllTypes::Builder::getInt8Field() { + return _builder.getDataField< ::int8_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInt8Field( ::int8_t value) { + _builder.setDataField< ::int8_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasInt16Field() const { + return _reader.hasDataField< ::int16_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasInt16Field() { + return _builder.hasDataField< ::int16_t>(1 * ::capnp::ELEMENTS); +} +inline ::int16_t TestAllTypes::Reader::getInt16Field() const { + return _reader.getDataField< ::int16_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestAllTypes::Builder::getInt16Field() { + return _builder.getDataField< ::int16_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInt16Field( ::int16_t value) { + _builder.setDataField< ::int16_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasInt32Field() const { + return _reader.hasDataField< ::int32_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasInt32Field() { + return _builder.hasDataField< ::int32_t>(1 * ::capnp::ELEMENTS); +} +inline ::int32_t TestAllTypes::Reader::getInt32Field() const { + return _reader.getDataField< ::int32_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestAllTypes::Builder::getInt32Field() { + return _builder.getDataField< ::int32_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInt32Field( ::int32_t value) { + _builder.setDataField< ::int32_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasInt64Field() const { + return _reader.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasInt64Field() { + return _builder.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} +inline ::int64_t TestAllTypes::Reader::getInt64Field() const { + return _reader.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestAllTypes::Builder::getInt64Field() { + return _builder.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInt64Field( ::int64_t value) { + _builder.setDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasUInt8Field() const { + return _reader.hasDataField< ::uint8_t>(16 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasUInt8Field() { + return _builder.hasDataField< ::uint8_t>(16 * ::capnp::ELEMENTS); +} +inline ::uint8_t TestAllTypes::Reader::getUInt8Field() const { + return _reader.getDataField< ::uint8_t>( + 16 * ::capnp::ELEMENTS); +} + +inline ::uint8_t TestAllTypes::Builder::getUInt8Field() { + return _builder.getDataField< ::uint8_t>( + 16 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setUInt8Field( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + 16 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasUInt16Field() const { + return _reader.hasDataField< ::uint16_t>(9 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasUInt16Field() { + return _builder.hasDataField< ::uint16_t>(9 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestAllTypes::Reader::getUInt16Field() const { + return _reader.getDataField< ::uint16_t>( + 9 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestAllTypes::Builder::getUInt16Field() { + return _builder.getDataField< ::uint16_t>( + 9 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setUInt16Field( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + 9 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasUInt32Field() const { + return _reader.hasDataField< ::uint32_t>(5 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasUInt32Field() { + return _builder.hasDataField< ::uint32_t>(5 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestAllTypes::Reader::getUInt32Field() const { + return _reader.getDataField< ::uint32_t>( + 5 * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestAllTypes::Builder::getUInt32Field() { + return _builder.getDataField< ::uint32_t>( + 5 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setUInt32Field( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + 5 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasUInt64Field() const { + return _reader.hasDataField< ::uint64_t>(3 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasUInt64Field() { + return _builder.hasDataField< ::uint64_t>(3 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestAllTypes::Reader::getUInt64Field() const { + return _reader.getDataField< ::uint64_t>( + 3 * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestAllTypes::Builder::getUInt64Field() { + return _builder.getDataField< ::uint64_t>( + 3 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setUInt64Field( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 3 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasFloat32Field() const { + return _reader.hasDataField(8 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasFloat32Field() { + return _builder.hasDataField(8 * ::capnp::ELEMENTS); +} +inline float TestAllTypes::Reader::getFloat32Field() const { + return _reader.getDataField( + 8 * ::capnp::ELEMENTS); +} + +inline float TestAllTypes::Builder::getFloat32Field() { + return _builder.getDataField( + 8 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setFloat32Field(float value) { + _builder.setDataField( + 8 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasFloat64Field() const { + return _reader.hasDataField(5 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasFloat64Field() { + return _builder.hasDataField(5 * ::capnp::ELEMENTS); +} +inline double TestAllTypes::Reader::getFloat64Field() const { + return _reader.getDataField( + 5 * ::capnp::ELEMENTS); +} + +inline double TestAllTypes::Builder::getFloat64Field() { + return _builder.getDataField( + 5 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setFloat64Field(double value) { + _builder.setDataField( + 5 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasTextField() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasTextField() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestAllTypes::Reader::getTextField() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestAllTypes::Builder::getTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setTextField( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestAllTypes::Builder::initTextField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptTextField( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestAllTypes::Builder::disownTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasDataField() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasDataField() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Data::Reader TestAllTypes::Reader::getDataField() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Data::Builder TestAllTypes::Builder::getDataField() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setDataField( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Data::Builder TestAllTypes::Builder::initDataField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptDataField( + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Data> TestAllTypes::Builder::disownDataField() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasStructField() const { + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasStructField() { + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Reader TestAllTypes::Reader::getStructField() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get( + _reader.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestAllTypes::Builder::getStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline TestAllTypes::Pipeline::getStructField() const { + return ::capnproto_test::capnp::test::TestAllTypes::Pipeline(_typeless.getPointerField(2)); +} +inline void TestAllTypes::Builder::setStructField( ::capnproto_test::capnp::test::TestAllTypes::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestAllTypes::Builder::initStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::init( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::adoptStructField( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> TestAllTypes::Builder::disownStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasEnumField() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestEnum>(18 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasEnumField() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestEnum>(18 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestEnum TestAllTypes::Reader::getEnumField() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestEnum>( + 18 * ::capnp::ELEMENTS); +} + +inline ::capnproto_test::capnp::test::TestEnum TestAllTypes::Builder::getEnumField() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestEnum>( + 18 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setEnumField( ::capnproto_test::capnp::test::TestEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestEnum>( + 18 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasInterfaceField() const { + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestAllTypes::Builder::hasInterfaceField() { + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestAllTypes::Reader::getInterfaceField() const { + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestAllTypes::Builder::getInterfaceField() { + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestAllTypes::Builder::setInterfaceField( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestAllTypes::Reader::hasVoidList() const { + return !_reader.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasVoidList() { + return !_builder.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Void>::Reader TestAllTypes::Reader::getVoidList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::get( + _reader.getPointerField(3 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Void>::Builder TestAllTypes::Builder::getVoidList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::get( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setVoidList( ::capnp::List< ::capnp::Void>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setVoidList(std::initializer_list< ::capnp::Void> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Void>::Builder TestAllTypes::Builder::initVoidList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::init( + _builder.getPointerField(3 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptVoidList( + ::capnp::Orphan< ::capnp::List< ::capnp::Void>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::adopt( + _builder.getPointerField(3 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Void>> TestAllTypes::Builder::disownVoidList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::disown( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasBoolList() const { + return !_reader.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasBoolList() { + return !_builder.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestAllTypes::Reader::getBoolList() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _reader.getPointerField(4 * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder TestAllTypes::Builder::getBoolList() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setBoolList( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(4 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setBoolList(std::initializer_list value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(4 * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestAllTypes::Builder::initBoolList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init( + _builder.getPointerField(4 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptBoolList( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt( + _builder.getPointerField(4 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestAllTypes::Builder::disownBoolList() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInt8List() const { + return !_reader.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInt8List() { + return !_builder.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int8_t>::Reader TestAllTypes::Reader::getInt8List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::get( + _reader.getPointerField(5 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int8_t>::Builder TestAllTypes::Builder::getInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::get( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInt8List( ::capnp::List< ::int8_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::set( + _builder.getPointerField(5 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInt8List(std::initializer_list< ::int8_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::set( + _builder.getPointerField(5 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int8_t>::Builder TestAllTypes::Builder::initInt8List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::init( + _builder.getPointerField(5 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInt8List( + ::capnp::Orphan< ::capnp::List< ::int8_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::adopt( + _builder.getPointerField(5 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int8_t>> TestAllTypes::Builder::disownInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::disown( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInt16List() const { + return !_reader.getPointerField(6 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInt16List() { + return !_builder.getPointerField(6 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int16_t>::Reader TestAllTypes::Reader::getInt16List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::get( + _reader.getPointerField(6 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int16_t>::Builder TestAllTypes::Builder::getInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::get( + _builder.getPointerField(6 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInt16List( ::capnp::List< ::int16_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::set( + _builder.getPointerField(6 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInt16List(std::initializer_list< ::int16_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::set( + _builder.getPointerField(6 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int16_t>::Builder TestAllTypes::Builder::initInt16List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::init( + _builder.getPointerField(6 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInt16List( + ::capnp::Orphan< ::capnp::List< ::int16_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::adopt( + _builder.getPointerField(6 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int16_t>> TestAllTypes::Builder::disownInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::disown( + _builder.getPointerField(6 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInt32List() const { + return !_reader.getPointerField(7 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInt32List() { + return !_builder.getPointerField(7 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t>::Reader TestAllTypes::Reader::getInt32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::get( + _reader.getPointerField(7 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int32_t>::Builder TestAllTypes::Builder::getInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::get( + _builder.getPointerField(7 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInt32List( ::capnp::List< ::int32_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::set( + _builder.getPointerField(7 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInt32List(std::initializer_list< ::int32_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::set( + _builder.getPointerField(7 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t>::Builder TestAllTypes::Builder::initInt32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::init( + _builder.getPointerField(7 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInt32List( + ::capnp::Orphan< ::capnp::List< ::int32_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::adopt( + _builder.getPointerField(7 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int32_t>> TestAllTypes::Builder::disownInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::disown( + _builder.getPointerField(7 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInt64List() const { + return !_reader.getPointerField(8 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInt64List() { + return !_builder.getPointerField(8 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int64_t>::Reader TestAllTypes::Reader::getInt64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::get( + _reader.getPointerField(8 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int64_t>::Builder TestAllTypes::Builder::getInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::get( + _builder.getPointerField(8 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInt64List( ::capnp::List< ::int64_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::set( + _builder.getPointerField(8 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInt64List(std::initializer_list< ::int64_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::set( + _builder.getPointerField(8 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int64_t>::Builder TestAllTypes::Builder::initInt64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::init( + _builder.getPointerField(8 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInt64List( + ::capnp::Orphan< ::capnp::List< ::int64_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::adopt( + _builder.getPointerField(8 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int64_t>> TestAllTypes::Builder::disownInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::disown( + _builder.getPointerField(8 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasUInt8List() const { + return !_reader.getPointerField(9 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasUInt8List() { + return !_builder.getPointerField(9 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint8_t>::Reader TestAllTypes::Reader::getUInt8List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::get( + _reader.getPointerField(9 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint8_t>::Builder TestAllTypes::Builder::getUInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::get( + _builder.getPointerField(9 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setUInt8List( ::capnp::List< ::uint8_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::set( + _builder.getPointerField(9 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setUInt8List(std::initializer_list< ::uint8_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::set( + _builder.getPointerField(9 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint8_t>::Builder TestAllTypes::Builder::initUInt8List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::init( + _builder.getPointerField(9 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptUInt8List( + ::capnp::Orphan< ::capnp::List< ::uint8_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::adopt( + _builder.getPointerField(9 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint8_t>> TestAllTypes::Builder::disownUInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::disown( + _builder.getPointerField(9 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasUInt16List() const { + return !_reader.getPointerField(10 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasUInt16List() { + return !_builder.getPointerField(10 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint16_t>::Reader TestAllTypes::Reader::getUInt16List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::get( + _reader.getPointerField(10 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint16_t>::Builder TestAllTypes::Builder::getUInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::get( + _builder.getPointerField(10 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setUInt16List( ::capnp::List< ::uint16_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::set( + _builder.getPointerField(10 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setUInt16List(std::initializer_list< ::uint16_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::set( + _builder.getPointerField(10 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint16_t>::Builder TestAllTypes::Builder::initUInt16List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::init( + _builder.getPointerField(10 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptUInt16List( + ::capnp::Orphan< ::capnp::List< ::uint16_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::adopt( + _builder.getPointerField(10 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint16_t>> TestAllTypes::Builder::disownUInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::disown( + _builder.getPointerField(10 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasUInt32List() const { + return !_reader.getPointerField(11 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasUInt32List() { + return !_builder.getPointerField(11 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t>::Reader TestAllTypes::Reader::getUInt32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::get( + _reader.getPointerField(11 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint32_t>::Builder TestAllTypes::Builder::getUInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::get( + _builder.getPointerField(11 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setUInt32List( ::capnp::List< ::uint32_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::set( + _builder.getPointerField(11 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setUInt32List(std::initializer_list< ::uint32_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::set( + _builder.getPointerField(11 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t>::Builder TestAllTypes::Builder::initUInt32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::init( + _builder.getPointerField(11 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptUInt32List( + ::capnp::Orphan< ::capnp::List< ::uint32_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::adopt( + _builder.getPointerField(11 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t>> TestAllTypes::Builder::disownUInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::disown( + _builder.getPointerField(11 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasUInt64List() const { + return !_reader.getPointerField(12 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasUInt64List() { + return !_builder.getPointerField(12 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t>::Reader TestAllTypes::Reader::getUInt64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::get( + _reader.getPointerField(12 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::uint64_t>::Builder TestAllTypes::Builder::getUInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::get( + _builder.getPointerField(12 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setUInt64List( ::capnp::List< ::uint64_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::set( + _builder.getPointerField(12 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setUInt64List(std::initializer_list< ::uint64_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::set( + _builder.getPointerField(12 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t>::Builder TestAllTypes::Builder::initUInt64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::init( + _builder.getPointerField(12 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptUInt64List( + ::capnp::Orphan< ::capnp::List< ::uint64_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::adopt( + _builder.getPointerField(12 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t>> TestAllTypes::Builder::disownUInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::disown( + _builder.getPointerField(12 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasFloat32List() const { + return !_reader.getPointerField(13 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasFloat32List() { + return !_builder.getPointerField(13 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestAllTypes::Reader::getFloat32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _reader.getPointerField(13 * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder TestAllTypes::Builder::getFloat32List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _builder.getPointerField(13 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setFloat32List( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(13 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setFloat32List(std::initializer_list value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(13 * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestAllTypes::Builder::initFloat32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init( + _builder.getPointerField(13 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptFloat32List( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt( + _builder.getPointerField(13 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestAllTypes::Builder::disownFloat32List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown( + _builder.getPointerField(13 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasFloat64List() const { + return !_reader.getPointerField(14 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasFloat64List() { + return !_builder.getPointerField(14 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestAllTypes::Reader::getFloat64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _reader.getPointerField(14 * ::capnp::POINTERS)); +} +inline ::capnp::List::Builder TestAllTypes::Builder::getFloat64List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _builder.getPointerField(14 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setFloat64List( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(14 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setFloat64List(std::initializer_list value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(14 * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestAllTypes::Builder::initFloat64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init( + _builder.getPointerField(14 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptFloat64List( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt( + _builder.getPointerField(14 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestAllTypes::Builder::disownFloat64List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown( + _builder.getPointerField(14 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasTextList() const { + return !_reader.getPointerField(15 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasTextList() { + return !_builder.getPointerField(15 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text>::Reader TestAllTypes::Reader::getTextList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::get( + _reader.getPointerField(15 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Text>::Builder TestAllTypes::Builder::getTextList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::get( + _builder.getPointerField(15 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setTextList( ::capnp::List< ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::set( + _builder.getPointerField(15 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setTextList(std::initializer_list< ::capnp::Text::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::set( + _builder.getPointerField(15 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text>::Builder TestAllTypes::Builder::initTextList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::init( + _builder.getPointerField(15 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptTextList( + ::capnp::Orphan< ::capnp::List< ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::adopt( + _builder.getPointerField(15 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text>> TestAllTypes::Builder::disownTextList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::disown( + _builder.getPointerField(15 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasDataList() const { + return !_reader.getPointerField(16 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasDataList() { + return !_builder.getPointerField(16 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Data>::Reader TestAllTypes::Reader::getDataList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::get( + _reader.getPointerField(16 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Data>::Builder TestAllTypes::Builder::getDataList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::get( + _builder.getPointerField(16 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setDataList( ::capnp::List< ::capnp::Data>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::set( + _builder.getPointerField(16 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setDataList(std::initializer_list< ::capnp::Data::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::set( + _builder.getPointerField(16 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Data>::Builder TestAllTypes::Builder::initDataList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::init( + _builder.getPointerField(16 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptDataList( + ::capnp::Orphan< ::capnp::List< ::capnp::Data>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::adopt( + _builder.getPointerField(16 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Data>> TestAllTypes::Builder::disownDataList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::disown( + _builder.getPointerField(16 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasStructList() const { + return !_reader.getPointerField(17 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasStructList() { + return !_builder.getPointerField(17 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader TestAllTypes::Reader::getStructList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::get( + _reader.getPointerField(17 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Builder TestAllTypes::Builder::getStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::get( + _builder.getPointerField(17 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::set( + _builder.getPointerField(17 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Builder TestAllTypes::Builder::initStructList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::init( + _builder.getPointerField(17 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptStructList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::adopt( + _builder.getPointerField(17 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>> TestAllTypes::Builder::disownStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::disown( + _builder.getPointerField(17 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasEnumList() const { + return !_reader.getPointerField(18 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasEnumList() { + return !_builder.getPointerField(18 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Reader TestAllTypes::Reader::getEnumList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::get( + _reader.getPointerField(18 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Builder TestAllTypes::Builder::getEnumList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::get( + _builder.getPointerField(18 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setEnumList( ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::set( + _builder.getPointerField(18 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setEnumList(std::initializer_list< ::capnproto_test::capnp::test::TestEnum> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::set( + _builder.getPointerField(18 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Builder TestAllTypes::Builder::initEnumList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::init( + _builder.getPointerField(18 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptEnumList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::adopt( + _builder.getPointerField(18 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>> TestAllTypes::Builder::disownEnumList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::disown( + _builder.getPointerField(18 * ::capnp::POINTERS)); +} + +inline bool TestAllTypes::Reader::hasInterfaceList() const { + return !_reader.getPointerField(19 * ::capnp::POINTERS).isNull(); +} +inline bool TestAllTypes::Builder::hasInterfaceList() { + return !_builder.getPointerField(19 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Void>::Reader TestAllTypes::Reader::getInterfaceList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::get( + _reader.getPointerField(19 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Void>::Builder TestAllTypes::Builder::getInterfaceList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::get( + _builder.getPointerField(19 * ::capnp::POINTERS)); +} +inline void TestAllTypes::Builder::setInterfaceList( ::capnp::List< ::capnp::Void>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::set( + _builder.getPointerField(19 * ::capnp::POINTERS), value); +} +inline void TestAllTypes::Builder::setInterfaceList(std::initializer_list< ::capnp::Void> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::set( + _builder.getPointerField(19 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Void>::Builder TestAllTypes::Builder::initInterfaceList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::init( + _builder.getPointerField(19 * ::capnp::POINTERS), size); +} +inline void TestAllTypes::Builder::adoptInterfaceList( + ::capnp::Orphan< ::capnp::List< ::capnp::Void>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::adopt( + _builder.getPointerField(19 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Void>> TestAllTypes::Builder::disownInterfaceList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::disown( + _builder.getPointerField(19 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasVoidField() const { + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasVoidField() { + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestDefaults::Reader::getVoidField() const { + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestDefaults::Builder::getVoidField() { + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestDefaults::Builder::setVoidField( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestDefaults::Reader::hasBoolField() const { + return _reader.hasDataField(0 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasBoolField() { + return _builder.hasDataField(0 * ::capnp::ELEMENTS); +} +inline bool TestDefaults::Reader::getBoolField() const { + return _reader.getDataField( + 0 * ::capnp::ELEMENTS, true); +} + +inline bool TestDefaults::Builder::getBoolField() { + return _builder.getDataField( + 0 * ::capnp::ELEMENTS, true); +} +inline void TestDefaults::Builder::setBoolField(bool value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, value, true); +} + +inline bool TestDefaults::Reader::hasInt8Field() const { + return _reader.hasDataField< ::int8_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasInt8Field() { + return _builder.hasDataField< ::int8_t>(1 * ::capnp::ELEMENTS); +} +inline ::int8_t TestDefaults::Reader::getInt8Field() const { + return _reader.getDataField< ::int8_t>( + 1 * ::capnp::ELEMENTS, -123); +} + +inline ::int8_t TestDefaults::Builder::getInt8Field() { + return _builder.getDataField< ::int8_t>( + 1 * ::capnp::ELEMENTS, -123); +} +inline void TestDefaults::Builder::setInt8Field( ::int8_t value) { + _builder.setDataField< ::int8_t>( + 1 * ::capnp::ELEMENTS, value, -123); +} + +inline bool TestDefaults::Reader::hasInt16Field() const { + return _reader.hasDataField< ::int16_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasInt16Field() { + return _builder.hasDataField< ::int16_t>(1 * ::capnp::ELEMENTS); +} +inline ::int16_t TestDefaults::Reader::getInt16Field() const { + return _reader.getDataField< ::int16_t>( + 1 * ::capnp::ELEMENTS, -12345); +} + +inline ::int16_t TestDefaults::Builder::getInt16Field() { + return _builder.getDataField< ::int16_t>( + 1 * ::capnp::ELEMENTS, -12345); +} +inline void TestDefaults::Builder::setInt16Field( ::int16_t value) { + _builder.setDataField< ::int16_t>( + 1 * ::capnp::ELEMENTS, value, -12345); +} + +inline bool TestDefaults::Reader::hasInt32Field() const { + return _reader.hasDataField< ::int32_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasInt32Field() { + return _builder.hasDataField< ::int32_t>(1 * ::capnp::ELEMENTS); +} +inline ::int32_t TestDefaults::Reader::getInt32Field() const { + return _reader.getDataField< ::int32_t>( + 1 * ::capnp::ELEMENTS, -12345678); +} + +inline ::int32_t TestDefaults::Builder::getInt32Field() { + return _builder.getDataField< ::int32_t>( + 1 * ::capnp::ELEMENTS, -12345678); +} +inline void TestDefaults::Builder::setInt32Field( ::int32_t value) { + _builder.setDataField< ::int32_t>( + 1 * ::capnp::ELEMENTS, value, -12345678); +} + +inline bool TestDefaults::Reader::hasInt64Field() const { + return _reader.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasInt64Field() { + return _builder.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} +inline ::int64_t TestDefaults::Reader::getInt64Field() const { + return _reader.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, -123456789012345ll); +} + +inline ::int64_t TestDefaults::Builder::getInt64Field() { + return _builder.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, -123456789012345ll); +} +inline void TestDefaults::Builder::setInt64Field( ::int64_t value) { + _builder.setDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, value, -123456789012345ll); +} + +inline bool TestDefaults::Reader::hasUInt8Field() const { + return _reader.hasDataField< ::uint8_t>(16 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasUInt8Field() { + return _builder.hasDataField< ::uint8_t>(16 * ::capnp::ELEMENTS); +} +inline ::uint8_t TestDefaults::Reader::getUInt8Field() const { + return _reader.getDataField< ::uint8_t>( + 16 * ::capnp::ELEMENTS, 234u); +} + +inline ::uint8_t TestDefaults::Builder::getUInt8Field() { + return _builder.getDataField< ::uint8_t>( + 16 * ::capnp::ELEMENTS, 234u); +} +inline void TestDefaults::Builder::setUInt8Field( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + 16 * ::capnp::ELEMENTS, value, 234u); +} + +inline bool TestDefaults::Reader::hasUInt16Field() const { + return _reader.hasDataField< ::uint16_t>(9 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasUInt16Field() { + return _builder.hasDataField< ::uint16_t>(9 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestDefaults::Reader::getUInt16Field() const { + return _reader.getDataField< ::uint16_t>( + 9 * ::capnp::ELEMENTS, 45678u); +} + +inline ::uint16_t TestDefaults::Builder::getUInt16Field() { + return _builder.getDataField< ::uint16_t>( + 9 * ::capnp::ELEMENTS, 45678u); +} +inline void TestDefaults::Builder::setUInt16Field( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + 9 * ::capnp::ELEMENTS, value, 45678u); +} + +inline bool TestDefaults::Reader::hasUInt32Field() const { + return _reader.hasDataField< ::uint32_t>(5 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasUInt32Field() { + return _builder.hasDataField< ::uint32_t>(5 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestDefaults::Reader::getUInt32Field() const { + return _reader.getDataField< ::uint32_t>( + 5 * ::capnp::ELEMENTS, 3456789012u); +} + +inline ::uint32_t TestDefaults::Builder::getUInt32Field() { + return _builder.getDataField< ::uint32_t>( + 5 * ::capnp::ELEMENTS, 3456789012u); +} +inline void TestDefaults::Builder::setUInt32Field( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + 5 * ::capnp::ELEMENTS, value, 3456789012u); +} + +inline bool TestDefaults::Reader::hasUInt64Field() const { + return _reader.hasDataField< ::uint64_t>(3 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasUInt64Field() { + return _builder.hasDataField< ::uint64_t>(3 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestDefaults::Reader::getUInt64Field() const { + return _reader.getDataField< ::uint64_t>( + 3 * ::capnp::ELEMENTS, 12345678901234567890ull); +} + +inline ::uint64_t TestDefaults::Builder::getUInt64Field() { + return _builder.getDataField< ::uint64_t>( + 3 * ::capnp::ELEMENTS, 12345678901234567890ull); +} +inline void TestDefaults::Builder::setUInt64Field( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 3 * ::capnp::ELEMENTS, value, 12345678901234567890ull); +} + +inline bool TestDefaults::Reader::hasFloat32Field() const { + return _reader.hasDataField(8 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasFloat32Field() { + return _builder.hasDataField(8 * ::capnp::ELEMENTS); +} +inline float TestDefaults::Reader::getFloat32Field() const { + return _reader.getDataField( + 8 * ::capnp::ELEMENTS, 1150963712u); +} + +inline float TestDefaults::Builder::getFloat32Field() { + return _builder.getDataField( + 8 * ::capnp::ELEMENTS, 1150963712u); +} +inline void TestDefaults::Builder::setFloat32Field(float value) { + _builder.setDataField( + 8 * ::capnp::ELEMENTS, value, 1150963712u); +} + +inline bool TestDefaults::Reader::hasFloat64Field() const { + return _reader.hasDataField(5 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasFloat64Field() { + return _builder.hasDataField(5 * ::capnp::ELEMENTS); +} +inline double TestDefaults::Reader::getFloat64Field() const { + return _reader.getDataField( + 5 * ::capnp::ELEMENTS, 14534676766106106624ull); +} + +inline double TestDefaults::Builder::getFloat64Field() { + return _builder.getDataField( + 5 * ::capnp::ELEMENTS, 14534676766106106624ull); +} +inline void TestDefaults::Builder::setFloat64Field(double value) { + _builder.setDataField( + 5 * ::capnp::ELEMENTS, value, 14534676766106106624ull); +} + +inline bool TestDefaults::Reader::hasTextField() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasTextField() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestDefaults::Reader::getTextField() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 359, 3); +} +inline ::capnp::Text::Builder TestDefaults::Builder::getTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 359, 3); +} +inline void TestDefaults::Builder::setTextField( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestDefaults::Builder::initTextField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptTextField( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestDefaults::Builder::disownTextField() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasDataField() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasDataField() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Data::Reader TestDefaults::Reader::getDataField() const { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get( + _reader.getPointerField(1 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 368, 3); +} +inline ::capnp::Data::Builder TestDefaults::Builder::getDataField() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::get( + _builder.getPointerField(1 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 368, 3); +} +inline void TestDefaults::Builder::setDataField( ::capnp::Data::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Data::Builder TestDefaults::Builder::initDataField(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Data>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptDataField( + ::capnp::Orphan< ::capnp::Data>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Data>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Data> TestDefaults::Builder::disownDataField() { + return ::capnp::_::PointerHelpers< ::capnp::Data>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasStructField() const { + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasStructField() { + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Reader TestDefaults::Reader::getStructField() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get( + _reader.getPointerField(2 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 376); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestDefaults::Builder::getStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get( + _builder.getPointerField(2 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 376); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline TestDefaults::Pipeline::getStructField() const { + return ::capnproto_test::capnp::test::TestAllTypes::Pipeline(_typeless.getPointerField(2)); +} +inline void TestDefaults::Builder::setStructField( ::capnproto_test::capnp::test::TestAllTypes::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestDefaults::Builder::initStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::init( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestDefaults::Builder::adoptStructField( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> TestDefaults::Builder::disownStructField() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasEnumField() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestEnum>(18 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasEnumField() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestEnum>(18 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestEnum TestDefaults::Reader::getEnumField() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestEnum>( + 18 * ::capnp::ELEMENTS, 5u); +} + +inline ::capnproto_test::capnp::test::TestEnum TestDefaults::Builder::getEnumField() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestEnum>( + 18 * ::capnp::ELEMENTS, 5u); +} +inline void TestDefaults::Builder::setEnumField( ::capnproto_test::capnp::test::TestEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestEnum>( + 18 * ::capnp::ELEMENTS, value, 5u); +} + +inline bool TestDefaults::Reader::hasInterfaceField() const { + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestDefaults::Builder::hasInterfaceField() { + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestDefaults::Reader::getInterfaceField() const { + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestDefaults::Builder::getInterfaceField() { + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestDefaults::Builder::setInterfaceField( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestDefaults::Reader::hasVoidList() const { + return !_reader.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasVoidList() { + return !_builder.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Void>::Reader TestDefaults::Reader::getVoidList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::get( + _reader.getPointerField(3 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 610); +} +inline ::capnp::List< ::capnp::Void>::Builder TestDefaults::Builder::getVoidList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::get( + _builder.getPointerField(3 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 610); +} +inline void TestDefaults::Builder::setVoidList( ::capnp::List< ::capnp::Void>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setVoidList(std::initializer_list< ::capnp::Void> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Void>::Builder TestDefaults::Builder::initVoidList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::init( + _builder.getPointerField(3 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptVoidList( + ::capnp::Orphan< ::capnp::List< ::capnp::Void>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::adopt( + _builder.getPointerField(3 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Void>> TestDefaults::Builder::disownVoidList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::disown( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasBoolList() const { + return !_reader.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasBoolList() { + return !_builder.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestDefaults::Reader::getBoolList() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _reader.getPointerField(4 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 621); +} +inline ::capnp::List::Builder TestDefaults::Builder::getBoolList() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _builder.getPointerField(4 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 621); +} +inline void TestDefaults::Builder::setBoolList( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(4 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setBoolList(std::initializer_list value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(4 * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestDefaults::Builder::initBoolList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init( + _builder.getPointerField(4 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptBoolList( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt( + _builder.getPointerField(4 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestDefaults::Builder::disownBoolList() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInt8List() const { + return !_reader.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInt8List() { + return !_builder.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int8_t>::Reader TestDefaults::Reader::getInt8List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::get( + _reader.getPointerField(5 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 633); +} +inline ::capnp::List< ::int8_t>::Builder TestDefaults::Builder::getInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::get( + _builder.getPointerField(5 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 633); +} +inline void TestDefaults::Builder::setInt8List( ::capnp::List< ::int8_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::set( + _builder.getPointerField(5 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInt8List(std::initializer_list< ::int8_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::set( + _builder.getPointerField(5 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int8_t>::Builder TestDefaults::Builder::initInt8List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::init( + _builder.getPointerField(5 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInt8List( + ::capnp::Orphan< ::capnp::List< ::int8_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::adopt( + _builder.getPointerField(5 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int8_t>> TestDefaults::Builder::disownInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int8_t>>::disown( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInt16List() const { + return !_reader.getPointerField(6 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInt16List() { + return !_builder.getPointerField(6 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int16_t>::Reader TestDefaults::Reader::getInt16List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::get( + _reader.getPointerField(6 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 645); +} +inline ::capnp::List< ::int16_t>::Builder TestDefaults::Builder::getInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::get( + _builder.getPointerField(6 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 645); +} +inline void TestDefaults::Builder::setInt16List( ::capnp::List< ::int16_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::set( + _builder.getPointerField(6 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInt16List(std::initializer_list< ::int16_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::set( + _builder.getPointerField(6 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int16_t>::Builder TestDefaults::Builder::initInt16List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::init( + _builder.getPointerField(6 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInt16List( + ::capnp::Orphan< ::capnp::List< ::int16_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::adopt( + _builder.getPointerField(6 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int16_t>> TestDefaults::Builder::disownInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int16_t>>::disown( + _builder.getPointerField(6 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInt32List() const { + return !_reader.getPointerField(7 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInt32List() { + return !_builder.getPointerField(7 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t>::Reader TestDefaults::Reader::getInt32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::get( + _reader.getPointerField(7 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 657); +} +inline ::capnp::List< ::int32_t>::Builder TestDefaults::Builder::getInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::get( + _builder.getPointerField(7 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 657); +} +inline void TestDefaults::Builder::setInt32List( ::capnp::List< ::int32_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::set( + _builder.getPointerField(7 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInt32List(std::initializer_list< ::int32_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::set( + _builder.getPointerField(7 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t>::Builder TestDefaults::Builder::initInt32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::init( + _builder.getPointerField(7 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInt32List( + ::capnp::Orphan< ::capnp::List< ::int32_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::adopt( + _builder.getPointerField(7 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int32_t>> TestDefaults::Builder::disownInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::disown( + _builder.getPointerField(7 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInt64List() const { + return !_reader.getPointerField(8 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInt64List() { + return !_builder.getPointerField(8 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int64_t>::Reader TestDefaults::Reader::getInt64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::get( + _reader.getPointerField(8 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 669); +} +inline ::capnp::List< ::int64_t>::Builder TestDefaults::Builder::getInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::get( + _builder.getPointerField(8 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 669); +} +inline void TestDefaults::Builder::setInt64List( ::capnp::List< ::int64_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::set( + _builder.getPointerField(8 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInt64List(std::initializer_list< ::int64_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::set( + _builder.getPointerField(8 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int64_t>::Builder TestDefaults::Builder::initInt64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::init( + _builder.getPointerField(8 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInt64List( + ::capnp::Orphan< ::capnp::List< ::int64_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::adopt( + _builder.getPointerField(8 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int64_t>> TestDefaults::Builder::disownInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::int64_t>>::disown( + _builder.getPointerField(8 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasUInt8List() const { + return !_reader.getPointerField(9 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasUInt8List() { + return !_builder.getPointerField(9 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint8_t>::Reader TestDefaults::Reader::getUInt8List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::get( + _reader.getPointerField(9 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 682); +} +inline ::capnp::List< ::uint8_t>::Builder TestDefaults::Builder::getUInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::get( + _builder.getPointerField(9 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 682); +} +inline void TestDefaults::Builder::setUInt8List( ::capnp::List< ::uint8_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::set( + _builder.getPointerField(9 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setUInt8List(std::initializer_list< ::uint8_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::set( + _builder.getPointerField(9 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint8_t>::Builder TestDefaults::Builder::initUInt8List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::init( + _builder.getPointerField(9 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptUInt8List( + ::capnp::Orphan< ::capnp::List< ::uint8_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::adopt( + _builder.getPointerField(9 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint8_t>> TestDefaults::Builder::disownUInt8List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint8_t>>::disown( + _builder.getPointerField(9 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasUInt16List() const { + return !_reader.getPointerField(10 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasUInt16List() { + return !_builder.getPointerField(10 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint16_t>::Reader TestDefaults::Reader::getUInt16List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::get( + _reader.getPointerField(10 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 694); +} +inline ::capnp::List< ::uint16_t>::Builder TestDefaults::Builder::getUInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::get( + _builder.getPointerField(10 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 694); +} +inline void TestDefaults::Builder::setUInt16List( ::capnp::List< ::uint16_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::set( + _builder.getPointerField(10 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setUInt16List(std::initializer_list< ::uint16_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::set( + _builder.getPointerField(10 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint16_t>::Builder TestDefaults::Builder::initUInt16List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::init( + _builder.getPointerField(10 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptUInt16List( + ::capnp::Orphan< ::capnp::List< ::uint16_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::adopt( + _builder.getPointerField(10 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint16_t>> TestDefaults::Builder::disownUInt16List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint16_t>>::disown( + _builder.getPointerField(10 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasUInt32List() const { + return !_reader.getPointerField(11 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasUInt32List() { + return !_builder.getPointerField(11 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint32_t>::Reader TestDefaults::Reader::getUInt32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::get( + _reader.getPointerField(11 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 706); +} +inline ::capnp::List< ::uint32_t>::Builder TestDefaults::Builder::getUInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::get( + _builder.getPointerField(11 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 706); +} +inline void TestDefaults::Builder::setUInt32List( ::capnp::List< ::uint32_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::set( + _builder.getPointerField(11 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setUInt32List(std::initializer_list< ::uint32_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::set( + _builder.getPointerField(11 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint32_t>::Builder TestDefaults::Builder::initUInt32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::init( + _builder.getPointerField(11 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptUInt32List( + ::capnp::Orphan< ::capnp::List< ::uint32_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::adopt( + _builder.getPointerField(11 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint32_t>> TestDefaults::Builder::disownUInt32List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint32_t>>::disown( + _builder.getPointerField(11 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasUInt64List() const { + return !_reader.getPointerField(12 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasUInt64List() { + return !_builder.getPointerField(12 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::uint64_t>::Reader TestDefaults::Reader::getUInt64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::get( + _reader.getPointerField(12 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 718); +} +inline ::capnp::List< ::uint64_t>::Builder TestDefaults::Builder::getUInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::get( + _builder.getPointerField(12 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 718); +} +inline void TestDefaults::Builder::setUInt64List( ::capnp::List< ::uint64_t>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::set( + _builder.getPointerField(12 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setUInt64List(std::initializer_list< ::uint64_t> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::set( + _builder.getPointerField(12 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::uint64_t>::Builder TestDefaults::Builder::initUInt64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::init( + _builder.getPointerField(12 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptUInt64List( + ::capnp::Orphan< ::capnp::List< ::uint64_t>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::adopt( + _builder.getPointerField(12 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::uint64_t>> TestDefaults::Builder::disownUInt64List() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::uint64_t>>::disown( + _builder.getPointerField(12 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasFloat32List() const { + return !_reader.getPointerField(13 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasFloat32List() { + return !_builder.getPointerField(13 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestDefaults::Reader::getFloat32List() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _reader.getPointerField(13 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 730); +} +inline ::capnp::List::Builder TestDefaults::Builder::getFloat32List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _builder.getPointerField(13 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 730); +} +inline void TestDefaults::Builder::setFloat32List( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(13 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setFloat32List(std::initializer_list value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(13 * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestDefaults::Builder::initFloat32List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init( + _builder.getPointerField(13 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptFloat32List( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt( + _builder.getPointerField(13 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestDefaults::Builder::disownFloat32List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown( + _builder.getPointerField(13 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasFloat64List() const { + return !_reader.getPointerField(14 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasFloat64List() { + return !_builder.getPointerField(14 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List::Reader TestDefaults::Reader::getFloat64List() const { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _reader.getPointerField(14 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 743); +} +inline ::capnp::List::Builder TestDefaults::Builder::getFloat64List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::get( + _builder.getPointerField(14 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 743); +} +inline void TestDefaults::Builder::setFloat64List( ::capnp::List::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(14 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setFloat64List(std::initializer_list value) { + ::capnp::_::PointerHelpers< ::capnp::List>::set( + _builder.getPointerField(14 * ::capnp::POINTERS), value); +} +inline ::capnp::List::Builder TestDefaults::Builder::initFloat64List(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List>::init( + _builder.getPointerField(14 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptFloat64List( + ::capnp::Orphan< ::capnp::List>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List>::adopt( + _builder.getPointerField(14 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List> TestDefaults::Builder::disownFloat64List() { + return ::capnp::_::PointerHelpers< ::capnp::List>::disown( + _builder.getPointerField(14 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasTextList() const { + return !_reader.getPointerField(15 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasTextList() { + return !_builder.getPointerField(15 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Text>::Reader TestDefaults::Reader::getTextList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::get( + _reader.getPointerField(15 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 758); +} +inline ::capnp::List< ::capnp::Text>::Builder TestDefaults::Builder::getTextList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::get( + _builder.getPointerField(15 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 758); +} +inline void TestDefaults::Builder::setTextList( ::capnp::List< ::capnp::Text>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::set( + _builder.getPointerField(15 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setTextList(std::initializer_list< ::capnp::Text::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::set( + _builder.getPointerField(15 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Text>::Builder TestDefaults::Builder::initTextList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::init( + _builder.getPointerField(15 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptTextList( + ::capnp::Orphan< ::capnp::List< ::capnp::Text>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::adopt( + _builder.getPointerField(15 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Text>> TestDefaults::Builder::disownTextList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Text>>::disown( + _builder.getPointerField(15 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasDataList() const { + return !_reader.getPointerField(16 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasDataList() { + return !_builder.getPointerField(16 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Data>::Reader TestDefaults::Reader::getDataList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::get( + _reader.getPointerField(16 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 775); +} +inline ::capnp::List< ::capnp::Data>::Builder TestDefaults::Builder::getDataList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::get( + _builder.getPointerField(16 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 775); +} +inline void TestDefaults::Builder::setDataList( ::capnp::List< ::capnp::Data>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::set( + _builder.getPointerField(16 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setDataList(std::initializer_list< ::capnp::Data::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::set( + _builder.getPointerField(16 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Data>::Builder TestDefaults::Builder::initDataList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::init( + _builder.getPointerField(16 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptDataList( + ::capnp::Orphan< ::capnp::List< ::capnp::Data>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::adopt( + _builder.getPointerField(16 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Data>> TestDefaults::Builder::disownDataList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Data>>::disown( + _builder.getPointerField(16 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasStructList() const { + return !_reader.getPointerField(17 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasStructList() { + return !_builder.getPointerField(17 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader TestDefaults::Reader::getStructList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::get( + _reader.getPointerField(17 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 793); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Builder TestDefaults::Builder::getStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::get( + _builder.getPointerField(17 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 793); +} +inline void TestDefaults::Builder::setStructList( ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::set( + _builder.getPointerField(17 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Builder TestDefaults::Builder::initStructList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::init( + _builder.getPointerField(17 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptStructList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::adopt( + _builder.getPointerField(17 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>> TestDefaults::Builder::disownStructList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::disown( + _builder.getPointerField(17 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasEnumList() const { + return !_reader.getPointerField(18 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasEnumList() { + return !_builder.getPointerField(18 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Reader TestDefaults::Reader::getEnumList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::get( + _reader.getPointerField(18 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 889); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Builder TestDefaults::Builder::getEnumList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::get( + _builder.getPointerField(18 * ::capnp::POINTERS), + ::capnp::schemas::s_eb3f9ebe98c73cb6.encodedNode + 889); +} +inline void TestDefaults::Builder::setEnumList( ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::set( + _builder.getPointerField(18 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setEnumList(std::initializer_list< ::capnproto_test::capnp::test::TestEnum> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::set( + _builder.getPointerField(18 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestEnum>::Builder TestDefaults::Builder::initEnumList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::init( + _builder.getPointerField(18 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptEnumList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::adopt( + _builder.getPointerField(18 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>> TestDefaults::Builder::disownEnumList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestEnum>>::disown( + _builder.getPointerField(18 * ::capnp::POINTERS)); +} + +inline bool TestDefaults::Reader::hasInterfaceList() const { + return !_reader.getPointerField(19 * ::capnp::POINTERS).isNull(); +} +inline bool TestDefaults::Builder::hasInterfaceList() { + return !_builder.getPointerField(19 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::Void>::Reader TestDefaults::Reader::getInterfaceList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::get( + _reader.getPointerField(19 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::Void>::Builder TestDefaults::Builder::getInterfaceList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::get( + _builder.getPointerField(19 * ::capnp::POINTERS)); +} +inline void TestDefaults::Builder::setInterfaceList( ::capnp::List< ::capnp::Void>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::set( + _builder.getPointerField(19 * ::capnp::POINTERS), value); +} +inline void TestDefaults::Builder::setInterfaceList(std::initializer_list< ::capnp::Void> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::set( + _builder.getPointerField(19 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::Void>::Builder TestDefaults::Builder::initInterfaceList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::init( + _builder.getPointerField(19 * ::capnp::POINTERS), size); +} +inline void TestDefaults::Builder::adoptInterfaceList( + ::capnp::Orphan< ::capnp::List< ::capnp::Void>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::adopt( + _builder.getPointerField(19 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::Void>> TestDefaults::Builder::disownInterfaceList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::Void>>::disown( + _builder.getPointerField(19 * ::capnp::POINTERS)); +} + +inline bool TestObject::Reader::hasObjectField() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestObject::Builder::hasObjectField() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::ObjectPointer::Reader TestObject::Reader::getObjectField() const { + return ::capnp::ObjectPointer::Reader( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::ObjectPointer::Builder TestObject::Builder::getObjectField() { + return ::capnp::ObjectPointer::Builder( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::ObjectPointer::Builder TestObject::Builder::initObjectField() { + auto result = ::capnp::ObjectPointer::Builder( + _builder.getPointerField(0 * ::capnp::POINTERS)); + result.clear(); + return result; +} + +inline bool TestOutOfOrder::Reader::hasQux() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasQux() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getQux() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getQux() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setQux( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initQux(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptQux( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownQux() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasGrault() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasGrault() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getGrault() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setGrault( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initGrault(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptGrault( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasBar() const { + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasBar() { + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getBar() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getBar() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setBar( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(2 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptBar( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownBar() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasFoo() const { + return !_reader.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasFoo() { + return !_builder.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getFoo() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(3 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getFoo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setFoo( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initFoo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(3 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptFoo( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(3 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownFoo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasCorge() const { + return !_reader.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasCorge() { + return !_builder.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getCorge() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(4 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getCorge() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setCorge( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(4 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initCorge(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(4 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptCorge( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(4 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownCorge() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasWaldo() const { + return !_reader.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasWaldo() { + return !_builder.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getWaldo() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(5 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setWaldo( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(5 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initWaldo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(5 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptWaldo( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(5 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasQuux() const { + return !_reader.getPointerField(6 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasQuux() { + return !_builder.getPointerField(6 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getQuux() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(6 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getQuux() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(6 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setQuux( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(6 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initQuux(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(6 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptQuux( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(6 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownQuux() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(6 * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasGarply() const { + return !_reader.getPointerField(7 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasGarply() { + return !_builder.getPointerField(7 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getGarply() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(7 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(7 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setGarply( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(7 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initGarply(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(7 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptGarply( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(7 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(7 * ::capnp::POINTERS)); +} + +inline bool TestOutOfOrder::Reader::hasBaz() const { + return !_reader.getPointerField(8 * ::capnp::POINTERS).isNull(); +} +inline bool TestOutOfOrder::Builder::hasBaz() { + return !_builder.getPointerField(8 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOutOfOrder::Reader::getBaz() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(8 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::getBaz() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(8 * ::capnp::POINTERS)); +} +inline void TestOutOfOrder::Builder::setBaz( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(8 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOutOfOrder::Builder::initBaz(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(8 * ::capnp::POINTERS), size); +} +inline void TestOutOfOrder::Builder::adoptBaz( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(8 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOutOfOrder::Builder::disownBaz() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(8 * ::capnp::POINTERS)); +} + +inline bool TestUnion::Reader::hasUnion0() const { + return _reader.getDataField< ::uint16_t>(0 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Builder::hasUnion0() { + return _builder.getDataField< ::uint16_t>(0 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline TestUnion::Union0::Reader TestUnion::Reader::getUnion0() const { + return TestUnion::Union0::Reader(_reader); +} +inline TestUnion::Union0::Builder TestUnion::Builder::getUnion0() { + return TestUnion::Union0::Builder(_builder); +} +inline TestUnion::Union0::Pipeline TestUnion::Pipeline::getUnion0() const { + return TestUnion::Union0::Pipeline(_typeless.noop()); +} +inline TestUnion::Union0::Builder TestUnion::Builder::initUnion0() { + _builder.setDataField< ::uint16_t>(0 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(1 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(0 * ::capnp::POINTERS).clear(); + return TestUnion::Union0::Builder(_builder); +} +inline bool TestUnion::Reader::hasUnion1() const { + return _reader.getDataField< ::uint16_t>(1 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField(129 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint8_t>(17 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(9 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint32_t>(5 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(3 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Builder::hasUnion1() { + return _builder.getDataField< ::uint16_t>(1 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField(129 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint8_t>(17 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(9 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint32_t>(5 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(3 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline TestUnion::Union1::Reader TestUnion::Reader::getUnion1() const { + return TestUnion::Union1::Reader(_reader); +} +inline TestUnion::Union1::Builder TestUnion::Builder::getUnion1() { + return TestUnion::Union1::Builder(_builder); +} +inline TestUnion::Union1::Pipeline TestUnion::Pipeline::getUnion1() const { + return TestUnion::Union1::Pipeline(_typeless.noop()); +} +inline TestUnion::Union1::Builder TestUnion::Builder::initUnion1() { + _builder.setDataField< ::uint16_t>(1 * ::capnp::ELEMENTS, 0); + _builder.setDataField(129 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint8_t>(17 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(9 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(5 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(3 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(1 * ::capnp::POINTERS).clear(); + return TestUnion::Union1::Builder(_builder); +} +inline bool TestUnion::Reader::hasUnion2() const { + return _reader.getDataField< ::uint16_t>(2 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField(256 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint8_t>(33 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(18 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint32_t>(10 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(6 * ::capnp::ELEMENTS) != 0; +} +inline bool TestUnion::Builder::hasUnion2() { + return _builder.getDataField< ::uint16_t>(2 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField(256 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint8_t>(33 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(18 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint32_t>(10 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(6 * ::capnp::ELEMENTS) != 0; +} +inline TestUnion::Union2::Reader TestUnion::Reader::getUnion2() const { + return TestUnion::Union2::Reader(_reader); +} +inline TestUnion::Union2::Builder TestUnion::Builder::getUnion2() { + return TestUnion::Union2::Builder(_builder); +} +inline TestUnion::Union2::Pipeline TestUnion::Pipeline::getUnion2() const { + return TestUnion::Union2::Pipeline(_typeless.noop()); +} +inline TestUnion::Union2::Builder TestUnion::Builder::initUnion2() { + _builder.setDataField< ::uint16_t>(2 * ::capnp::ELEMENTS, 0); + _builder.setDataField(256 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint8_t>(33 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(18 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(10 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(6 * ::capnp::ELEMENTS, 0); + return TestUnion::Union2::Builder(_builder); +} +inline bool TestUnion::Reader::hasUnion3() const { + return _reader.getDataField< ::uint16_t>(3 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField(257 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint8_t>(34 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(19 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint32_t>(11 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(7 * ::capnp::ELEMENTS) != 0; +} +inline bool TestUnion::Builder::hasUnion3() { + return _builder.getDataField< ::uint16_t>(3 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField(257 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint8_t>(34 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(19 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint32_t>(11 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(7 * ::capnp::ELEMENTS) != 0; +} +inline TestUnion::Union3::Reader TestUnion::Reader::getUnion3() const { + return TestUnion::Union3::Reader(_reader); +} +inline TestUnion::Union3::Builder TestUnion::Builder::getUnion3() { + return TestUnion::Union3::Builder(_builder); +} +inline TestUnion::Union3::Pipeline TestUnion::Pipeline::getUnion3() const { + return TestUnion::Union3::Pipeline(_typeless.noop()); +} +inline TestUnion::Union3::Builder TestUnion::Builder::initUnion3() { + _builder.setDataField< ::uint16_t>(3 * ::capnp::ELEMENTS, 0); + _builder.setDataField(257 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint8_t>(34 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(19 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(11 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(7 * ::capnp::ELEMENTS, 0); + return TestUnion::Union3::Builder(_builder); +} +inline bool TestUnion::Reader::hasBit0() const { + return _reader.hasDataField(128 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::hasBit0() { + return _builder.hasDataField(128 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Reader::getBit0() const { + return _reader.getDataField( + 128 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit0() { + return _builder.getDataField( + 128 * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit0(bool value) { + _builder.setDataField( + 128 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::hasBit2() const { + return _reader.hasDataField(130 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::hasBit2() { + return _builder.hasDataField(130 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Reader::getBit2() const { + return _reader.getDataField( + 130 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit2() { + return _builder.getDataField( + 130 * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit2(bool value) { + _builder.setDataField( + 130 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::hasBit3() const { + return _reader.hasDataField(131 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::hasBit3() { + return _builder.hasDataField(131 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Reader::getBit3() const { + return _reader.getDataField( + 131 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit3() { + return _builder.getDataField( + 131 * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit3(bool value) { + _builder.setDataField( + 131 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::hasBit4() const { + return _reader.hasDataField(132 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::hasBit4() { + return _builder.hasDataField(132 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Reader::getBit4() const { + return _reader.getDataField( + 132 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit4() { + return _builder.getDataField( + 132 * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit4(bool value) { + _builder.setDataField( + 132 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::hasBit5() const { + return _reader.hasDataField(133 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::hasBit5() { + return _builder.hasDataField(133 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Reader::getBit5() const { + return _reader.getDataField( + 133 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit5() { + return _builder.getDataField( + 133 * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit5(bool value) { + _builder.setDataField( + 133 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::hasBit6() const { + return _reader.hasDataField(134 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::hasBit6() { + return _builder.hasDataField(134 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Reader::getBit6() const { + return _reader.getDataField( + 134 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit6() { + return _builder.getDataField( + 134 * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit6(bool value) { + _builder.setDataField( + 134 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::hasBit7() const { + return _reader.hasDataField(135 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::hasBit7() { + return _builder.hasDataField(135 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Reader::getBit7() const { + return _reader.getDataField( + 135 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::getBit7() { + return _builder.getDataField( + 135 * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setBit7(bool value) { + _builder.setDataField( + 135 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Reader::hasByte0() const { + return _reader.hasDataField< ::uint8_t>(35 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Builder::hasByte0() { + return _builder.hasDataField< ::uint8_t>(35 * ::capnp::ELEMENTS); +} +inline ::uint8_t TestUnion::Reader::getByte0() const { + return _reader.getDataField< ::uint8_t>( + 35 * ::capnp::ELEMENTS); +} + +inline ::uint8_t TestUnion::Builder::getByte0() { + return _builder.getDataField< ::uint8_t>( + 35 * ::capnp::ELEMENTS); +} +inline void TestUnion::Builder::setByte0( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + 35 * ::capnp::ELEMENTS, value); +} + +inline TestUnion::Union0::Which TestUnion::Union0::Reader::which() const { + return _reader.getDataField(0 * ::capnp::ELEMENTS); +} +inline TestUnion::Union0::Which TestUnion::Union0::Builder::which() { + return _builder.getDataField(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Reader::isU0f0s0() const { + return which() == TestUnion::Union0::U0F0S0; +} +inline bool TestUnion::Union0::Builder::isU0f0s0() { + return which() == TestUnion::Union0::U0F0S0; +} +inline bool TestUnion::Union0::Reader::hasU0f0s0() const { + if (which() != TestUnion::Union0::U0F0S0) return false; + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f0s0() { + if (which() != TestUnion::Union0::U0F0S0) return false; + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestUnion::Union0::Reader::getU0f0s0() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S0, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestUnion::Union0::Builder::getU0f0s0() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S0, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s0( ::capnp::Void value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S0); + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s1() const { + return which() == TestUnion::Union0::U0F0S1; +} +inline bool TestUnion::Union0::Builder::isU0f0s1() { + return which() == TestUnion::Union0::U0F0S1; +} +inline bool TestUnion::Union0::Reader::hasU0f0s1() const { + if (which() != TestUnion::Union0::U0F0S1) return false; + return _reader.hasDataField(64 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f0s1() { + if (which() != TestUnion::Union0::U0F0S1) return false; + return _builder.hasDataField(64 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Union0::Reader::getU0f0s1() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S1, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 64 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::getU0f0s1() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S1, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 64 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s1(bool value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S1); + _builder.setDataField( + 64 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s8() const { + return which() == TestUnion::Union0::U0F0S8; +} +inline bool TestUnion::Union0::Builder::isU0f0s8() { + return which() == TestUnion::Union0::U0F0S8; +} +inline bool TestUnion::Union0::Reader::hasU0f0s8() const { + if (which() != TestUnion::Union0::U0F0S8) return false; + return _reader.hasDataField< ::int8_t>(8 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f0s8() { + if (which() != TestUnion::Union0::U0F0S8) return false; + return _builder.hasDataField< ::int8_t>(8 * ::capnp::ELEMENTS); +} +inline ::int8_t TestUnion::Union0::Reader::getU0f0s8() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S8, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + 8 * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union0::Builder::getU0f0s8() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S8, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + 8 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s8( ::int8_t value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S8); + _builder.setDataField< ::int8_t>( + 8 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s16() const { + return which() == TestUnion::Union0::U0F0S16; +} +inline bool TestUnion::Union0::Builder::isU0f0s16() { + return which() == TestUnion::Union0::U0F0S16; +} +inline bool TestUnion::Union0::Reader::hasU0f0s16() const { + if (which() != TestUnion::Union0::U0F0S16) return false; + return _reader.hasDataField< ::int16_t>(4 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f0s16() { + if (which() != TestUnion::Union0::U0F0S16) return false; + return _builder.hasDataField< ::int16_t>(4 * ::capnp::ELEMENTS); +} +inline ::int16_t TestUnion::Union0::Reader::getU0f0s16() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S16, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + 4 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union0::Builder::getU0f0s16() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S16, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + 4 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s16( ::int16_t value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S16); + _builder.setDataField< ::int16_t>( + 4 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s32() const { + return which() == TestUnion::Union0::U0F0S32; +} +inline bool TestUnion::Union0::Builder::isU0f0s32() { + return which() == TestUnion::Union0::U0F0S32; +} +inline bool TestUnion::Union0::Reader::hasU0f0s32() const { + if (which() != TestUnion::Union0::U0F0S32) return false; + return _reader.hasDataField< ::int32_t>(2 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f0s32() { + if (which() != TestUnion::Union0::U0F0S32) return false; + return _builder.hasDataField< ::int32_t>(2 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnion::Union0::Reader::getU0f0s32() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S32, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 2 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union0::Builder::getU0f0s32() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S32, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 2 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s32( ::int32_t value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S32); + _builder.setDataField< ::int32_t>( + 2 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0s64() const { + return which() == TestUnion::Union0::U0F0S64; +} +inline bool TestUnion::Union0::Builder::isU0f0s64() { + return which() == TestUnion::Union0::U0F0S64; +} +inline bool TestUnion::Union0::Reader::hasU0f0s64() const { + if (which() != TestUnion::Union0::U0F0S64) return false; + return _reader.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f0s64() { + if (which() != TestUnion::Union0::U0F0S64) return false; + return _builder.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} +inline ::int64_t TestUnion::Union0::Reader::getU0f0s64() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S64, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union0::Builder::getU0f0s64() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0S64, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f0s64( ::int64_t value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0S64); + _builder.setDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f0sp() const { + return which() == TestUnion::Union0::U0F0SP; +} +inline bool TestUnion::Union0::Builder::isU0f0sp() { + return which() == TestUnion::Union0::U0F0SP; +} +inline bool TestUnion::Union0::Reader::hasU0f0sp() const { + if (which() != TestUnion::Union0::U0F0SP) return false; + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union0::Builder::hasU0f0sp() { + if (which() != TestUnion::Union0::U0F0SP) return false; + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union0::Reader::getU0f0sp() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union0::Builder::getU0f0sp() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestUnion::Union0::Builder::setU0f0sp( ::capnp::Text::Reader value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union0::Builder::initU0f0sp(unsigned int size) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestUnion::Union0::Builder::adoptU0f0sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F0SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union0::Builder::disownU0f0sp() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F0SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestUnion::Union0::Reader::isU0f1s0() const { + return which() == TestUnion::Union0::U0F1S0; +} +inline bool TestUnion::Union0::Builder::isU0f1s0() { + return which() == TestUnion::Union0::U0F1S0; +} +inline bool TestUnion::Union0::Reader::hasU0f1s0() const { + if (which() != TestUnion::Union0::U0F1S0) return false; + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f1s0() { + if (which() != TestUnion::Union0::U0F1S0) return false; + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestUnion::Union0::Reader::getU0f1s0() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S0, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestUnion::Union0::Builder::getU0f1s0() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S0, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s0( ::capnp::Void value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S0); + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s1() const { + return which() == TestUnion::Union0::U0F1S1; +} +inline bool TestUnion::Union0::Builder::isU0f1s1() { + return which() == TestUnion::Union0::U0F1S1; +} +inline bool TestUnion::Union0::Reader::hasU0f1s1() const { + if (which() != TestUnion::Union0::U0F1S1) return false; + return _reader.hasDataField(64 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f1s1() { + if (which() != TestUnion::Union0::U0F1S1) return false; + return _builder.hasDataField(64 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Union0::Reader::getU0f1s1() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S1, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 64 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::getU0f1s1() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S1, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 64 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s1(bool value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S1); + _builder.setDataField( + 64 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s8() const { + return which() == TestUnion::Union0::U0F1S8; +} +inline bool TestUnion::Union0::Builder::isU0f1s8() { + return which() == TestUnion::Union0::U0F1S8; +} +inline bool TestUnion::Union0::Reader::hasU0f1s8() const { + if (which() != TestUnion::Union0::U0F1S8) return false; + return _reader.hasDataField< ::int8_t>(8 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f1s8() { + if (which() != TestUnion::Union0::U0F1S8) return false; + return _builder.hasDataField< ::int8_t>(8 * ::capnp::ELEMENTS); +} +inline ::int8_t TestUnion::Union0::Reader::getU0f1s8() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S8, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + 8 * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union0::Builder::getU0f1s8() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S8, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + 8 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s8( ::int8_t value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S8); + _builder.setDataField< ::int8_t>( + 8 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s16() const { + return which() == TestUnion::Union0::U0F1S16; +} +inline bool TestUnion::Union0::Builder::isU0f1s16() { + return which() == TestUnion::Union0::U0F1S16; +} +inline bool TestUnion::Union0::Reader::hasU0f1s16() const { + if (which() != TestUnion::Union0::U0F1S16) return false; + return _reader.hasDataField< ::int16_t>(4 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f1s16() { + if (which() != TestUnion::Union0::U0F1S16) return false; + return _builder.hasDataField< ::int16_t>(4 * ::capnp::ELEMENTS); +} +inline ::int16_t TestUnion::Union0::Reader::getU0f1s16() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S16, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + 4 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union0::Builder::getU0f1s16() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S16, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + 4 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s16( ::int16_t value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S16); + _builder.setDataField< ::int16_t>( + 4 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s32() const { + return which() == TestUnion::Union0::U0F1S32; +} +inline bool TestUnion::Union0::Builder::isU0f1s32() { + return which() == TestUnion::Union0::U0F1S32; +} +inline bool TestUnion::Union0::Reader::hasU0f1s32() const { + if (which() != TestUnion::Union0::U0F1S32) return false; + return _reader.hasDataField< ::int32_t>(2 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f1s32() { + if (which() != TestUnion::Union0::U0F1S32) return false; + return _builder.hasDataField< ::int32_t>(2 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnion::Union0::Reader::getU0f1s32() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S32, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 2 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union0::Builder::getU0f1s32() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S32, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 2 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s32( ::int32_t value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S32); + _builder.setDataField< ::int32_t>( + 2 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1s64() const { + return which() == TestUnion::Union0::U0F1S64; +} +inline bool TestUnion::Union0::Builder::isU0f1s64() { + return which() == TestUnion::Union0::U0F1S64; +} +inline bool TestUnion::Union0::Reader::hasU0f1s64() const { + if (which() != TestUnion::Union0::U0F1S64) return false; + return _reader.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union0::Builder::hasU0f1s64() { + if (which() != TestUnion::Union0::U0F1S64) return false; + return _builder.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} +inline ::int64_t TestUnion::Union0::Reader::getU0f1s64() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S64, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union0::Builder::getU0f1s64() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1S64, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union0::Builder::setU0f1s64( ::int64_t value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1S64); + _builder.setDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union0::Reader::isU0f1sp() const { + return which() == TestUnion::Union0::U0F1SP; +} +inline bool TestUnion::Union0::Builder::isU0f1sp() { + return which() == TestUnion::Union0::U0F1SP; +} +inline bool TestUnion::Union0::Reader::hasU0f1sp() const { + if (which() != TestUnion::Union0::U0F1SP) return false; + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union0::Builder::hasU0f1sp() { + if (which() != TestUnion::Union0::U0F1SP) return false; + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union0::Reader::getU0f1sp() const { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union0::Builder::getU0f1sp() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestUnion::Union0::Builder::setU0f1sp( ::capnp::Text::Reader value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union0::Builder::initU0f1sp(unsigned int size) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestUnion::Union0::Builder::adoptU0f1sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestUnion::Union0::U0F1SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union0::Builder::disownU0f1sp() { + KJ_IREQUIRE(which() == TestUnion::Union0::U0F1SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline TestUnion::Union1::Which TestUnion::Union1::Reader::which() const { + return _reader.getDataField(1 * ::capnp::ELEMENTS); +} +inline TestUnion::Union1::Which TestUnion::Union1::Builder::which() { + return _builder.getDataField(1 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Reader::isU1f0s0() const { + return which() == TestUnion::Union1::U1F0S0; +} +inline bool TestUnion::Union1::Builder::isU1f0s0() { + return which() == TestUnion::Union1::U1F0S0; +} +inline bool TestUnion::Union1::Reader::hasU1f0s0() const { + if (which() != TestUnion::Union1::U1F0S0) return false; + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f0s0() { + if (which() != TestUnion::Union1::U1F0S0) return false; + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestUnion::Union1::Reader::getU1f0s0() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S0, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestUnion::Union1::Builder::getU1f0s0() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S0, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s0( ::capnp::Void value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S0); + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s1() const { + return which() == TestUnion::Union1::U1F0S1; +} +inline bool TestUnion::Union1::Builder::isU1f0s1() { + return which() == TestUnion::Union1::U1F0S1; +} +inline bool TestUnion::Union1::Reader::hasU1f0s1() const { + if (which() != TestUnion::Union1::U1F0S1) return false; + return _reader.hasDataField(129 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f0s1() { + if (which() != TestUnion::Union1::U1F0S1) return false; + return _builder.hasDataField(129 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Union1::Reader::getU1f0s1() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S1, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 129 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::getU1f0s1() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S1, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 129 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s1(bool value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S1); + _builder.setDataField( + 129 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s1() const { + return which() == TestUnion::Union1::U1F1S1; +} +inline bool TestUnion::Union1::Builder::isU1f1s1() { + return which() == TestUnion::Union1::U1F1S1; +} +inline bool TestUnion::Union1::Reader::hasU1f1s1() const { + if (which() != TestUnion::Union1::U1F1S1) return false; + return _reader.hasDataField(129 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f1s1() { + if (which() != TestUnion::Union1::U1F1S1) return false; + return _builder.hasDataField(129 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Union1::Reader::getU1f1s1() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S1, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 129 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::getU1f1s1() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S1, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 129 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s1(bool value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S1); + _builder.setDataField( + 129 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s8() const { + return which() == TestUnion::Union1::U1F0S8; +} +inline bool TestUnion::Union1::Builder::isU1f0s8() { + return which() == TestUnion::Union1::U1F0S8; +} +inline bool TestUnion::Union1::Reader::hasU1f0s8() const { + if (which() != TestUnion::Union1::U1F0S8) return false; + return _reader.hasDataField< ::int8_t>(17 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f0s8() { + if (which() != TestUnion::Union1::U1F0S8) return false; + return _builder.hasDataField< ::int8_t>(17 * ::capnp::ELEMENTS); +} +inline ::int8_t TestUnion::Union1::Reader::getU1f0s8() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S8, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union1::Builder::getU1f0s8() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S8, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s8( ::int8_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S8); + _builder.setDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s8() const { + return which() == TestUnion::Union1::U1F1S8; +} +inline bool TestUnion::Union1::Builder::isU1f1s8() { + return which() == TestUnion::Union1::U1F1S8; +} +inline bool TestUnion::Union1::Reader::hasU1f1s8() const { + if (which() != TestUnion::Union1::U1F1S8) return false; + return _reader.hasDataField< ::int8_t>(17 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f1s8() { + if (which() != TestUnion::Union1::U1F1S8) return false; + return _builder.hasDataField< ::int8_t>(17 * ::capnp::ELEMENTS); +} +inline ::int8_t TestUnion::Union1::Reader::getU1f1s8() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S8, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union1::Builder::getU1f1s8() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S8, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s8( ::int8_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S8); + _builder.setDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s16() const { + return which() == TestUnion::Union1::U1F0S16; +} +inline bool TestUnion::Union1::Builder::isU1f0s16() { + return which() == TestUnion::Union1::U1F0S16; +} +inline bool TestUnion::Union1::Reader::hasU1f0s16() const { + if (which() != TestUnion::Union1::U1F0S16) return false; + return _reader.hasDataField< ::int16_t>(9 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f0s16() { + if (which() != TestUnion::Union1::U1F0S16) return false; + return _builder.hasDataField< ::int16_t>(9 * ::capnp::ELEMENTS); +} +inline ::int16_t TestUnion::Union1::Reader::getU1f0s16() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S16, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union1::Builder::getU1f0s16() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S16, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s16( ::int16_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S16); + _builder.setDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s16() const { + return which() == TestUnion::Union1::U1F1S16; +} +inline bool TestUnion::Union1::Builder::isU1f1s16() { + return which() == TestUnion::Union1::U1F1S16; +} +inline bool TestUnion::Union1::Reader::hasU1f1s16() const { + if (which() != TestUnion::Union1::U1F1S16) return false; + return _reader.hasDataField< ::int16_t>(9 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f1s16() { + if (which() != TestUnion::Union1::U1F1S16) return false; + return _builder.hasDataField< ::int16_t>(9 * ::capnp::ELEMENTS); +} +inline ::int16_t TestUnion::Union1::Reader::getU1f1s16() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S16, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union1::Builder::getU1f1s16() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S16, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s16( ::int16_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S16); + _builder.setDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s32() const { + return which() == TestUnion::Union1::U1F0S32; +} +inline bool TestUnion::Union1::Builder::isU1f0s32() { + return which() == TestUnion::Union1::U1F0S32; +} +inline bool TestUnion::Union1::Reader::hasU1f0s32() const { + if (which() != TestUnion::Union1::U1F0S32) return false; + return _reader.hasDataField< ::int32_t>(5 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f0s32() { + if (which() != TestUnion::Union1::U1F0S32) return false; + return _builder.hasDataField< ::int32_t>(5 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnion::Union1::Reader::getU1f0s32() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S32, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union1::Builder::getU1f0s32() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S32, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s32( ::int32_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S32); + _builder.setDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s32() const { + return which() == TestUnion::Union1::U1F1S32; +} +inline bool TestUnion::Union1::Builder::isU1f1s32() { + return which() == TestUnion::Union1::U1F1S32; +} +inline bool TestUnion::Union1::Reader::hasU1f1s32() const { + if (which() != TestUnion::Union1::U1F1S32) return false; + return _reader.hasDataField< ::int32_t>(5 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f1s32() { + if (which() != TestUnion::Union1::U1F1S32) return false; + return _builder.hasDataField< ::int32_t>(5 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnion::Union1::Reader::getU1f1s32() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S32, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union1::Builder::getU1f1s32() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S32, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s32( ::int32_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S32); + _builder.setDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0s64() const { + return which() == TestUnion::Union1::U1F0S64; +} +inline bool TestUnion::Union1::Builder::isU1f0s64() { + return which() == TestUnion::Union1::U1F0S64; +} +inline bool TestUnion::Union1::Reader::hasU1f0s64() const { + if (which() != TestUnion::Union1::U1F0S64) return false; + return _reader.hasDataField< ::int64_t>(3 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f0s64() { + if (which() != TestUnion::Union1::U1F0S64) return false; + return _builder.hasDataField< ::int64_t>(3 * ::capnp::ELEMENTS); +} +inline ::int64_t TestUnion::Union1::Reader::getU1f0s64() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S64, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union1::Builder::getU1f0s64() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0S64, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f0s64( ::int64_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0S64); + _builder.setDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f1s64() const { + return which() == TestUnion::Union1::U1F1S64; +} +inline bool TestUnion::Union1::Builder::isU1f1s64() { + return which() == TestUnion::Union1::U1F1S64; +} +inline bool TestUnion::Union1::Reader::hasU1f1s64() const { + if (which() != TestUnion::Union1::U1F1S64) return false; + return _reader.hasDataField< ::int64_t>(3 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f1s64() { + if (which() != TestUnion::Union1::U1F1S64) return false; + return _builder.hasDataField< ::int64_t>(3 * ::capnp::ELEMENTS); +} +inline ::int64_t TestUnion::Union1::Reader::getU1f1s64() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S64, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union1::Builder::getU1f1s64() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1S64, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f1s64( ::int64_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F1S64); + _builder.setDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f0sp() const { + return which() == TestUnion::Union1::U1F0SP; +} +inline bool TestUnion::Union1::Builder::isU1f0sp() { + return which() == TestUnion::Union1::U1F0SP; +} +inline bool TestUnion::Union1::Reader::hasU1f0sp() const { + if (which() != TestUnion::Union1::U1F0SP) return false; + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union1::Builder::hasU1f0sp() { + if (which() != TestUnion::Union1::U1F0SP) return false; + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union1::Reader::getU1f0sp() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::getU1f0sp() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestUnion::Union1::Builder::setU1f0sp( ::capnp::Text::Reader value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::initU1f0sp(unsigned int size) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestUnion::Union1::Builder::adoptU1f0sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F0SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union1::Builder::disownU1f0sp() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F0SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestUnion::Union1::Reader::isU1f1sp() const { + return which() == TestUnion::Union1::U1F1SP; +} +inline bool TestUnion::Union1::Builder::isU1f1sp() { + return which() == TestUnion::Union1::U1F1SP; +} +inline bool TestUnion::Union1::Reader::hasU1f1sp() const { + if (which() != TestUnion::Union1::U1F1SP) return false; + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union1::Builder::hasU1f1sp() { + if (which() != TestUnion::Union1::U1F1SP) return false; + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union1::Reader::getU1f1sp() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::getU1f1sp() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestUnion::Union1::Builder::setU1f1sp( ::capnp::Text::Reader value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F1SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::initU1f1sp(unsigned int size) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F1SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestUnion::Union1::Builder::adoptU1f1sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F1SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union1::Builder::disownU1f1sp() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F1SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestUnion::Union1::Reader::isU1f2s0() const { + return which() == TestUnion::Union1::U1F2S0; +} +inline bool TestUnion::Union1::Builder::isU1f2s0() { + return which() == TestUnion::Union1::U1F2S0; +} +inline bool TestUnion::Union1::Reader::hasU1f2s0() const { + if (which() != TestUnion::Union1::U1F2S0) return false; + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f2s0() { + if (which() != TestUnion::Union1::U1F2S0) return false; + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestUnion::Union1::Reader::getU1f2s0() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S0, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestUnion::Union1::Builder::getU1f2s0() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S0, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s0( ::capnp::Void value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S0); + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s1() const { + return which() == TestUnion::Union1::U1F2S1; +} +inline bool TestUnion::Union1::Builder::isU1f2s1() { + return which() == TestUnion::Union1::U1F2S1; +} +inline bool TestUnion::Union1::Reader::hasU1f2s1() const { + if (which() != TestUnion::Union1::U1F2S1) return false; + return _reader.hasDataField(129 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f2s1() { + if (which() != TestUnion::Union1::U1F2S1) return false; + return _builder.hasDataField(129 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Union1::Reader::getU1f2s1() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S1, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 129 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::getU1f2s1() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S1, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 129 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s1(bool value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S1); + _builder.setDataField( + 129 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s8() const { + return which() == TestUnion::Union1::U1F2S8; +} +inline bool TestUnion::Union1::Builder::isU1f2s8() { + return which() == TestUnion::Union1::U1F2S8; +} +inline bool TestUnion::Union1::Reader::hasU1f2s8() const { + if (which() != TestUnion::Union1::U1F2S8) return false; + return _reader.hasDataField< ::int8_t>(17 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f2s8() { + if (which() != TestUnion::Union1::U1F2S8) return false; + return _builder.hasDataField< ::int8_t>(17 * ::capnp::ELEMENTS); +} +inline ::int8_t TestUnion::Union1::Reader::getU1f2s8() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S8, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union1::Builder::getU1f2s8() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S8, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s8( ::int8_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S8); + _builder.setDataField< ::int8_t>( + 17 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s16() const { + return which() == TestUnion::Union1::U1F2S16; +} +inline bool TestUnion::Union1::Builder::isU1f2s16() { + return which() == TestUnion::Union1::U1F2S16; +} +inline bool TestUnion::Union1::Reader::hasU1f2s16() const { + if (which() != TestUnion::Union1::U1F2S16) return false; + return _reader.hasDataField< ::int16_t>(9 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f2s16() { + if (which() != TestUnion::Union1::U1F2S16) return false; + return _builder.hasDataField< ::int16_t>(9 * ::capnp::ELEMENTS); +} +inline ::int16_t TestUnion::Union1::Reader::getU1f2s16() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S16, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union1::Builder::getU1f2s16() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S16, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s16( ::int16_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S16); + _builder.setDataField< ::int16_t>( + 9 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s32() const { + return which() == TestUnion::Union1::U1F2S32; +} +inline bool TestUnion::Union1::Builder::isU1f2s32() { + return which() == TestUnion::Union1::U1F2S32; +} +inline bool TestUnion::Union1::Reader::hasU1f2s32() const { + if (which() != TestUnion::Union1::U1F2S32) return false; + return _reader.hasDataField< ::int32_t>(5 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f2s32() { + if (which() != TestUnion::Union1::U1F2S32) return false; + return _builder.hasDataField< ::int32_t>(5 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnion::Union1::Reader::getU1f2s32() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S32, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union1::Builder::getU1f2s32() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S32, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s32( ::int32_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S32); + _builder.setDataField< ::int32_t>( + 5 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2s64() const { + return which() == TestUnion::Union1::U1F2S64; +} +inline bool TestUnion::Union1::Builder::isU1f2s64() { + return which() == TestUnion::Union1::U1F2S64; +} +inline bool TestUnion::Union1::Reader::hasU1f2s64() const { + if (which() != TestUnion::Union1::U1F2S64) return false; + return _reader.hasDataField< ::int64_t>(3 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union1::Builder::hasU1f2s64() { + if (which() != TestUnion::Union1::U1F2S64) return false; + return _builder.hasDataField< ::int64_t>(3 * ::capnp::ELEMENTS); +} +inline ::int64_t TestUnion::Union1::Reader::getU1f2s64() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S64, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union1::Builder::getU1f2s64() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2S64, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union1::Builder::setU1f2s64( ::int64_t value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2S64); + _builder.setDataField< ::int64_t>( + 3 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union1::Reader::isU1f2sp() const { + return which() == TestUnion::Union1::U1F2SP; +} +inline bool TestUnion::Union1::Builder::isU1f2sp() { + return which() == TestUnion::Union1::U1F2SP; +} +inline bool TestUnion::Union1::Reader::hasU1f2sp() const { + if (which() != TestUnion::Union1::U1F2SP) return false; + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnion::Union1::Builder::hasU1f2sp() { + if (which() != TestUnion::Union1::U1F2SP) return false; + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnion::Union1::Reader::getU1f2sp() const { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::getU1f2sp() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestUnion::Union1::Builder::setU1f2sp( ::capnp::Text::Reader value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnion::Union1::Builder::initU1f2sp(unsigned int size) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2SP); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestUnion::Union1::Builder::adoptU1f2sp( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, TestUnion::Union1::U1F2SP); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnion::Union1::Builder::disownU1f2sp() { + KJ_IREQUIRE(which() == TestUnion::Union1::U1F2SP, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline TestUnion::Union2::Which TestUnion::Union2::Reader::which() const { + return _reader.getDataField(2 * ::capnp::ELEMENTS); +} +inline TestUnion::Union2::Which TestUnion::Union2::Builder::which() { + return _builder.getDataField(2 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Reader::isU2f0s1() const { + return which() == TestUnion::Union2::U2F0S1; +} +inline bool TestUnion::Union2::Builder::isU2f0s1() { + return which() == TestUnion::Union2::U2F0S1; +} +inline bool TestUnion::Union2::Reader::hasU2f0s1() const { + if (which() != TestUnion::Union2::U2F0S1) return false; + return _reader.hasDataField(256 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Builder::hasU2f0s1() { + if (which() != TestUnion::Union2::U2F0S1) return false; + return _builder.hasDataField(256 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Union2::Reader::getU2f0s1() const { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S1, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 256 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Builder::getU2f0s1() { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S1, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 256 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s1(bool value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S1); + _builder.setDataField( + 256 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union2::Reader::isU2f0s8() const { + return which() == TestUnion::Union2::U2F0S8; +} +inline bool TestUnion::Union2::Builder::isU2f0s8() { + return which() == TestUnion::Union2::U2F0S8; +} +inline bool TestUnion::Union2::Reader::hasU2f0s8() const { + if (which() != TestUnion::Union2::U2F0S8) return false; + return _reader.hasDataField< ::int8_t>(33 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Builder::hasU2f0s8() { + if (which() != TestUnion::Union2::U2F0S8) return false; + return _builder.hasDataField< ::int8_t>(33 * ::capnp::ELEMENTS); +} +inline ::int8_t TestUnion::Union2::Reader::getU2f0s8() const { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S8, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + 33 * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union2::Builder::getU2f0s8() { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S8, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + 33 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s8( ::int8_t value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S8); + _builder.setDataField< ::int8_t>( + 33 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union2::Reader::isU2f0s16() const { + return which() == TestUnion::Union2::U2F0S16; +} +inline bool TestUnion::Union2::Builder::isU2f0s16() { + return which() == TestUnion::Union2::U2F0S16; +} +inline bool TestUnion::Union2::Reader::hasU2f0s16() const { + if (which() != TestUnion::Union2::U2F0S16) return false; + return _reader.hasDataField< ::int16_t>(18 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Builder::hasU2f0s16() { + if (which() != TestUnion::Union2::U2F0S16) return false; + return _builder.hasDataField< ::int16_t>(18 * ::capnp::ELEMENTS); +} +inline ::int16_t TestUnion::Union2::Reader::getU2f0s16() const { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S16, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + 18 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union2::Builder::getU2f0s16() { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S16, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + 18 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s16( ::int16_t value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S16); + _builder.setDataField< ::int16_t>( + 18 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union2::Reader::isU2f0s32() const { + return which() == TestUnion::Union2::U2F0S32; +} +inline bool TestUnion::Union2::Builder::isU2f0s32() { + return which() == TestUnion::Union2::U2F0S32; +} +inline bool TestUnion::Union2::Reader::hasU2f0s32() const { + if (which() != TestUnion::Union2::U2F0S32) return false; + return _reader.hasDataField< ::int32_t>(10 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Builder::hasU2f0s32() { + if (which() != TestUnion::Union2::U2F0S32) return false; + return _builder.hasDataField< ::int32_t>(10 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnion::Union2::Reader::getU2f0s32() const { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S32, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 10 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union2::Builder::getU2f0s32() { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S32, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 10 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s32( ::int32_t value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S32); + _builder.setDataField< ::int32_t>( + 10 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union2::Reader::isU2f0s64() const { + return which() == TestUnion::Union2::U2F0S64; +} +inline bool TestUnion::Union2::Builder::isU2f0s64() { + return which() == TestUnion::Union2::U2F0S64; +} +inline bool TestUnion::Union2::Reader::hasU2f0s64() const { + if (which() != TestUnion::Union2::U2F0S64) return false; + return _reader.hasDataField< ::int64_t>(6 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union2::Builder::hasU2f0s64() { + if (which() != TestUnion::Union2::U2F0S64) return false; + return _builder.hasDataField< ::int64_t>(6 * ::capnp::ELEMENTS); +} +inline ::int64_t TestUnion::Union2::Reader::getU2f0s64() const { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S64, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + 6 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union2::Builder::getU2f0s64() { + KJ_IREQUIRE(which() == TestUnion::Union2::U2F0S64, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + 6 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union2::Builder::setU2f0s64( ::int64_t value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnion::Union2::U2F0S64); + _builder.setDataField< ::int64_t>( + 6 * ::capnp::ELEMENTS, value); +} + +inline TestUnion::Union3::Which TestUnion::Union3::Reader::which() const { + return _reader.getDataField(3 * ::capnp::ELEMENTS); +} +inline TestUnion::Union3::Which TestUnion::Union3::Builder::which() { + return _builder.getDataField(3 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Reader::isU3f0s1() const { + return which() == TestUnion::Union3::U3F0S1; +} +inline bool TestUnion::Union3::Builder::isU3f0s1() { + return which() == TestUnion::Union3::U3F0S1; +} +inline bool TestUnion::Union3::Reader::hasU3f0s1() const { + if (which() != TestUnion::Union3::U3F0S1) return false; + return _reader.hasDataField(257 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Builder::hasU3f0s1() { + if (which() != TestUnion::Union3::U3F0S1) return false; + return _builder.hasDataField(257 * ::capnp::ELEMENTS); +} +inline bool TestUnion::Union3::Reader::getU3f0s1() const { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S1, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 257 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Builder::getU3f0s1() { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S1, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 257 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s1(bool value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S1); + _builder.setDataField( + 257 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union3::Reader::isU3f0s8() const { + return which() == TestUnion::Union3::U3F0S8; +} +inline bool TestUnion::Union3::Builder::isU3f0s8() { + return which() == TestUnion::Union3::U3F0S8; +} +inline bool TestUnion::Union3::Reader::hasU3f0s8() const { + if (which() != TestUnion::Union3::U3F0S8) return false; + return _reader.hasDataField< ::int8_t>(34 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Builder::hasU3f0s8() { + if (which() != TestUnion::Union3::U3F0S8) return false; + return _builder.hasDataField< ::int8_t>(34 * ::capnp::ELEMENTS); +} +inline ::int8_t TestUnion::Union3::Reader::getU3f0s8() const { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S8, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int8_t>( + 34 * ::capnp::ELEMENTS); +} + +inline ::int8_t TestUnion::Union3::Builder::getU3f0s8() { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S8, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int8_t>( + 34 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s8( ::int8_t value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S8); + _builder.setDataField< ::int8_t>( + 34 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union3::Reader::isU3f0s16() const { + return which() == TestUnion::Union3::U3F0S16; +} +inline bool TestUnion::Union3::Builder::isU3f0s16() { + return which() == TestUnion::Union3::U3F0S16; +} +inline bool TestUnion::Union3::Reader::hasU3f0s16() const { + if (which() != TestUnion::Union3::U3F0S16) return false; + return _reader.hasDataField< ::int16_t>(19 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Builder::hasU3f0s16() { + if (which() != TestUnion::Union3::U3F0S16) return false; + return _builder.hasDataField< ::int16_t>(19 * ::capnp::ELEMENTS); +} +inline ::int16_t TestUnion::Union3::Reader::getU3f0s16() const { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S16, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int16_t>( + 19 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestUnion::Union3::Builder::getU3f0s16() { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S16, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int16_t>( + 19 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s16( ::int16_t value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S16); + _builder.setDataField< ::int16_t>( + 19 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union3::Reader::isU3f0s32() const { + return which() == TestUnion::Union3::U3F0S32; +} +inline bool TestUnion::Union3::Builder::isU3f0s32() { + return which() == TestUnion::Union3::U3F0S32; +} +inline bool TestUnion::Union3::Reader::hasU3f0s32() const { + if (which() != TestUnion::Union3::U3F0S32) return false; + return _reader.hasDataField< ::int32_t>(11 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Builder::hasU3f0s32() { + if (which() != TestUnion::Union3::U3F0S32) return false; + return _builder.hasDataField< ::int32_t>(11 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnion::Union3::Reader::getU3f0s32() const { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S32, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 11 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnion::Union3::Builder::getU3f0s32() { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S32, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 11 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s32( ::int32_t value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S32); + _builder.setDataField< ::int32_t>( + 11 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnion::Union3::Reader::isU3f0s64() const { + return which() == TestUnion::Union3::U3F0S64; +} +inline bool TestUnion::Union3::Builder::isU3f0s64() { + return which() == TestUnion::Union3::U3F0S64; +} +inline bool TestUnion::Union3::Reader::hasU3f0s64() const { + if (which() != TestUnion::Union3::U3F0S64) return false; + return _reader.hasDataField< ::int64_t>(7 * ::capnp::ELEMENTS); +} + +inline bool TestUnion::Union3::Builder::hasU3f0s64() { + if (which() != TestUnion::Union3::U3F0S64) return false; + return _builder.hasDataField< ::int64_t>(7 * ::capnp::ELEMENTS); +} +inline ::int64_t TestUnion::Union3::Reader::getU3f0s64() const { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S64, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int64_t>( + 7 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestUnion::Union3::Builder::getU3f0s64() { + KJ_IREQUIRE(which() == TestUnion::Union3::U3F0S64, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int64_t>( + 7 * ::capnp::ELEMENTS); +} +inline void TestUnion::Union3::Builder::setU3f0s64( ::int64_t value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestUnion::Union3::U3F0S64); + _builder.setDataField< ::int64_t>( + 7 * ::capnp::ELEMENTS, value); +} + +inline TestUnnamedUnion::Which TestUnnamedUnion::Reader::which() const { + return _reader.getDataField(2 * ::capnp::ELEMENTS); +} +inline TestUnnamedUnion::Which TestUnnamedUnion::Builder::which() { + return _builder.getDataField(2 * ::capnp::ELEMENTS); +} + +inline bool TestUnnamedUnion::Reader::hasBefore() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnnamedUnion::Builder::hasBefore() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnnamedUnion::Reader::getBefore() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnnamedUnion::Builder::getBefore() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestUnnamedUnion::Builder::setBefore( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnnamedUnion::Builder::initBefore(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestUnnamedUnion::Builder::adoptBefore( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnnamedUnion::Builder::disownBefore() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestUnnamedUnion::Reader::isFoo() const { + return which() == TestUnnamedUnion::FOO; +} +inline bool TestUnnamedUnion::Builder::isFoo() { + return which() == TestUnnamedUnion::FOO; +} +inline bool TestUnnamedUnion::Reader::hasFoo() const { + if (which() != TestUnnamedUnion::FOO) return false; + return _reader.hasDataField< ::uint16_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnnamedUnion::Builder::hasFoo() { + if (which() != TestUnnamedUnion::FOO) return false; + return _builder.hasDataField< ::uint16_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestUnnamedUnion::Reader::getFoo() const { + KJ_IREQUIRE(which() == TestUnnamedUnion::FOO, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestUnnamedUnion::Builder::getFoo() { + KJ_IREQUIRE(which() == TestUnnamedUnion::FOO, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestUnnamedUnion::Builder::setFoo( ::uint16_t value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnnamedUnion::FOO); + _builder.setDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnnamedUnion::Reader::hasMiddle() const { + return _reader.hasDataField< ::uint16_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestUnnamedUnion::Builder::hasMiddle() { + return _builder.hasDataField< ::uint16_t>(1 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestUnnamedUnion::Reader::getMiddle() const { + return _reader.getDataField< ::uint16_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestUnnamedUnion::Builder::getMiddle() { + return _builder.getDataField< ::uint16_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestUnnamedUnion::Builder::setMiddle( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnnamedUnion::Reader::isBar() const { + return which() == TestUnnamedUnion::BAR; +} +inline bool TestUnnamedUnion::Builder::isBar() { + return which() == TestUnnamedUnion::BAR; +} +inline bool TestUnnamedUnion::Reader::hasBar() const { + if (which() != TestUnnamedUnion::BAR) return false; + return _reader.hasDataField< ::uint32_t>(2 * ::capnp::ELEMENTS); +} + +inline bool TestUnnamedUnion::Builder::hasBar() { + if (which() != TestUnnamedUnion::BAR) return false; + return _builder.hasDataField< ::uint32_t>(2 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestUnnamedUnion::Reader::getBar() const { + KJ_IREQUIRE(which() == TestUnnamedUnion::BAR, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint32_t>( + 2 * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestUnnamedUnion::Builder::getBar() { + KJ_IREQUIRE(which() == TestUnnamedUnion::BAR, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint32_t>( + 2 * ::capnp::ELEMENTS); +} +inline void TestUnnamedUnion::Builder::setBar( ::uint32_t value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnnamedUnion::BAR); + _builder.setDataField< ::uint32_t>( + 2 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnnamedUnion::Reader::hasAfter() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnnamedUnion::Builder::hasAfter() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestUnnamedUnion::Reader::getAfter() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestUnnamedUnion::Builder::getAfter() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestUnnamedUnion::Builder::setAfter( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestUnnamedUnion::Builder::initAfter(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestUnnamedUnion::Builder::adoptAfter( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestUnnamedUnion::Builder::disownAfter() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestUnionInUnion::Reader::hasOuter() const { + return _reader.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(2 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(4 * ::capnp::ELEMENTS) != 0; +} +inline bool TestUnionInUnion::Builder::hasOuter() { + return _builder.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(2 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(4 * ::capnp::ELEMENTS) != 0; +} +inline TestUnionInUnion::Outer::Reader TestUnionInUnion::Reader::getOuter() const { + return TestUnionInUnion::Outer::Reader(_reader); +} +inline TestUnionInUnion::Outer::Builder TestUnionInUnion::Builder::getOuter() { + return TestUnionInUnion::Outer::Builder(_builder); +} +inline TestUnionInUnion::Outer::Pipeline TestUnionInUnion::Pipeline::getOuter() const { + return TestUnionInUnion::Outer::Pipeline(_typeless.noop()); +} +inline TestUnionInUnion::Outer::Builder TestUnionInUnion::Builder::initOuter() { + _builder.setDataField< ::uint32_t>(0 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(2 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(4 * ::capnp::ELEMENTS, 0); + return TestUnionInUnion::Outer::Builder(_builder); +} +inline TestUnionInUnion::Outer::Which TestUnionInUnion::Outer::Reader::which() const { + return _reader.getDataField(4 * ::capnp::ELEMENTS); +} +inline TestUnionInUnion::Outer::Which TestUnionInUnion::Outer::Builder::which() { + return _builder.getDataField(4 * ::capnp::ELEMENTS); +} + +inline bool TestUnionInUnion::Outer::Reader::isInner() const { + return which() == TestUnionInUnion::Outer::INNER; +} +inline bool TestUnionInUnion::Outer::Builder::isInner() { + return which() == TestUnionInUnion::Outer::INNER; +} +inline bool TestUnionInUnion::Outer::Reader::hasInner() const { + if (which() != TestUnionInUnion::Outer::INNER) return false; + return _reader.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(2 * ::capnp::ELEMENTS) != 0; +} +inline bool TestUnionInUnion::Outer::Builder::hasInner() { + if (which() != TestUnionInUnion::Outer::INNER) return false; + return _builder.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(2 * ::capnp::ELEMENTS) != 0; +} +inline TestUnionInUnion::Outer::Inner::Reader TestUnionInUnion::Outer::Reader::getInner() const { + KJ_IREQUIRE(which() == TestUnionInUnion::Outer::INNER, + "Must check which() before get()ing a union member."); + return TestUnionInUnion::Outer::Inner::Reader(_reader); +} +inline TestUnionInUnion::Outer::Inner::Builder TestUnionInUnion::Outer::Builder::getInner() { + KJ_IREQUIRE(which() == TestUnionInUnion::Outer::INNER, + "Must check which() before get()ing a union member."); + return TestUnionInUnion::Outer::Inner::Builder(_builder); +} +inline TestUnionInUnion::Outer::Inner::Builder TestUnionInUnion::Outer::Builder::initInner() { + _builder.setDataField( + 4 * ::capnp::ELEMENTS, TestUnionInUnion::Outer::INNER); + _builder.setDataField< ::uint32_t>(0 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(2 * ::capnp::ELEMENTS, 0); + return TestUnionInUnion::Outer::Inner::Builder(_builder); +} +inline bool TestUnionInUnion::Outer::Reader::isBaz() const { + return which() == TestUnionInUnion::Outer::BAZ; +} +inline bool TestUnionInUnion::Outer::Builder::isBaz() { + return which() == TestUnionInUnion::Outer::BAZ; +} +inline bool TestUnionInUnion::Outer::Reader::hasBaz() const { + if (which() != TestUnionInUnion::Outer::BAZ) return false; + return _reader.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnionInUnion::Outer::Builder::hasBaz() { + if (which() != TestUnionInUnion::Outer::BAZ) return false; + return _builder.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnionInUnion::Outer::Reader::getBaz() const { + KJ_IREQUIRE(which() == TestUnionInUnion::Outer::BAZ, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnionInUnion::Outer::Builder::getBaz() { + KJ_IREQUIRE(which() == TestUnionInUnion::Outer::BAZ, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestUnionInUnion::Outer::Builder::setBaz( ::int32_t value) { + _builder.setDataField( + 4 * ::capnp::ELEMENTS, TestUnionInUnion::Outer::BAZ); + _builder.setDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline TestUnionInUnion::Outer::Inner::Which TestUnionInUnion::Outer::Inner::Reader::which() const { + return _reader.getDataField(2 * ::capnp::ELEMENTS); +} +inline TestUnionInUnion::Outer::Inner::Which TestUnionInUnion::Outer::Inner::Builder::which() { + return _builder.getDataField(2 * ::capnp::ELEMENTS); +} + +inline bool TestUnionInUnion::Outer::Inner::Reader::isFoo() const { + return which() == TestUnionInUnion::Outer::Inner::FOO; +} +inline bool TestUnionInUnion::Outer::Inner::Builder::isFoo() { + return which() == TestUnionInUnion::Outer::Inner::FOO; +} +inline bool TestUnionInUnion::Outer::Inner::Reader::hasFoo() const { + if (which() != TestUnionInUnion::Outer::Inner::FOO) return false; + return _reader.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnionInUnion::Outer::Inner::Builder::hasFoo() { + if (which() != TestUnionInUnion::Outer::Inner::FOO) return false; + return _builder.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnionInUnion::Outer::Inner::Reader::getFoo() const { + KJ_IREQUIRE(which() == TestUnionInUnion::Outer::Inner::FOO, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnionInUnion::Outer::Inner::Builder::getFoo() { + KJ_IREQUIRE(which() == TestUnionInUnion::Outer::Inner::FOO, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestUnionInUnion::Outer::Inner::Builder::setFoo( ::int32_t value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnionInUnion::Outer::Inner::FOO); + _builder.setDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestUnionInUnion::Outer::Inner::Reader::isBar() const { + return which() == TestUnionInUnion::Outer::Inner::BAR; +} +inline bool TestUnionInUnion::Outer::Inner::Builder::isBar() { + return which() == TestUnionInUnion::Outer::Inner::BAR; +} +inline bool TestUnionInUnion::Outer::Inner::Reader::hasBar() const { + if (which() != TestUnionInUnion::Outer::Inner::BAR) return false; + return _reader.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUnionInUnion::Outer::Inner::Builder::hasBar() { + if (which() != TestUnionInUnion::Outer::Inner::BAR) return false; + return _builder.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} +inline ::int32_t TestUnionInUnion::Outer::Inner::Reader::getBar() const { + KJ_IREQUIRE(which() == TestUnionInUnion::Outer::Inner::BAR, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestUnionInUnion::Outer::Inner::Builder::getBar() { + KJ_IREQUIRE(which() == TestUnionInUnion::Outer::Inner::BAR, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestUnionInUnion::Outer::Inner::Builder::setBar( ::int32_t value) { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestUnionInUnion::Outer::Inner::BAR); + _builder.setDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestGroups::Reader::hasGroups() const { + return _reader.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(2 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(0 * ::capnp::POINTERS).isNull() + || !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Builder::hasGroups() { + return _builder.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(2 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(0 * ::capnp::POINTERS).isNull() + || !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline TestGroups::Groups::Reader TestGroups::Reader::getGroups() const { + return TestGroups::Groups::Reader(_reader); +} +inline TestGroups::Groups::Builder TestGroups::Builder::getGroups() { + return TestGroups::Groups::Builder(_builder); +} +inline TestGroups::Groups::Pipeline TestGroups::Pipeline::getGroups() const { + return TestGroups::Groups::Pipeline(_typeless.noop()); +} +inline TestGroups::Groups::Builder TestGroups::Builder::initGroups() { + _builder.setDataField< ::uint32_t>(0 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(2 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(1 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(0 * ::capnp::POINTERS).clear(); + _builder.getPointerField(1 * ::capnp::POINTERS).clear(); + return TestGroups::Groups::Builder(_builder); +} +inline TestGroups::Groups::Which TestGroups::Groups::Reader::which() const { + return _reader.getDataField(2 * ::capnp::ELEMENTS); +} +inline TestGroups::Groups::Which TestGroups::Groups::Builder::which() { + return _builder.getDataField(2 * ::capnp::ELEMENTS); +} + +inline bool TestGroups::Groups::Reader::isFoo() const { + return which() == TestGroups::Groups::FOO; +} +inline bool TestGroups::Groups::Builder::isFoo() { + return which() == TestGroups::Groups::FOO; +} +inline bool TestGroups::Groups::Reader::hasFoo() const { + if (which() != TestGroups::Groups::FOO) return false; + return _reader.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Builder::hasFoo() { + if (which() != TestGroups::Groups::FOO) return false; + return _builder.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline TestGroups::Groups::Foo::Reader TestGroups::Groups::Reader::getFoo() const { + KJ_IREQUIRE(which() == TestGroups::Groups::FOO, + "Must check which() before get()ing a union member."); + return TestGroups::Groups::Foo::Reader(_reader); +} +inline TestGroups::Groups::Foo::Builder TestGroups::Groups::Builder::getFoo() { + KJ_IREQUIRE(which() == TestGroups::Groups::FOO, + "Must check which() before get()ing a union member."); + return TestGroups::Groups::Foo::Builder(_builder); +} +inline TestGroups::Groups::Foo::Builder TestGroups::Groups::Builder::initFoo() { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestGroups::Groups::FOO); + _builder.setDataField< ::uint32_t>(0 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(1 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(0 * ::capnp::POINTERS).clear(); + return TestGroups::Groups::Foo::Builder(_builder); +} +inline bool TestGroups::Groups::Reader::isBaz() const { + return which() == TestGroups::Groups::BAZ; +} +inline bool TestGroups::Groups::Builder::isBaz() { + return which() == TestGroups::Groups::BAZ; +} +inline bool TestGroups::Groups::Reader::hasBaz() const { + if (which() != TestGroups::Groups::BAZ) return false; + return _reader.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(0 * ::capnp::POINTERS).isNull() + || !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Builder::hasBaz() { + if (which() != TestGroups::Groups::BAZ) return false; + return _builder.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(0 * ::capnp::POINTERS).isNull() + || !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline TestGroups::Groups::Baz::Reader TestGroups::Groups::Reader::getBaz() const { + KJ_IREQUIRE(which() == TestGroups::Groups::BAZ, + "Must check which() before get()ing a union member."); + return TestGroups::Groups::Baz::Reader(_reader); +} +inline TestGroups::Groups::Baz::Builder TestGroups::Groups::Builder::getBaz() { + KJ_IREQUIRE(which() == TestGroups::Groups::BAZ, + "Must check which() before get()ing a union member."); + return TestGroups::Groups::Baz::Builder(_builder); +} +inline TestGroups::Groups::Baz::Builder TestGroups::Groups::Builder::initBaz() { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestGroups::Groups::BAZ); + _builder.setDataField< ::uint32_t>(0 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(0 * ::capnp::POINTERS).clear(); + _builder.getPointerField(1 * ::capnp::POINTERS).clear(); + return TestGroups::Groups::Baz::Builder(_builder); +} +inline bool TestGroups::Groups::Reader::isBar() const { + return which() == TestGroups::Groups::BAR; +} +inline bool TestGroups::Groups::Builder::isBar() { + return which() == TestGroups::Groups::BAR; +} +inline bool TestGroups::Groups::Reader::hasBar() const { + if (which() != TestGroups::Groups::BAR) return false; + return _reader.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Builder::hasBar() { + if (which() != TestGroups::Groups::BAR) return false; + return _builder.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline TestGroups::Groups::Bar::Reader TestGroups::Groups::Reader::getBar() const { + KJ_IREQUIRE(which() == TestGroups::Groups::BAR, + "Must check which() before get()ing a union member."); + return TestGroups::Groups::Bar::Reader(_reader); +} +inline TestGroups::Groups::Bar::Builder TestGroups::Groups::Builder::getBar() { + KJ_IREQUIRE(which() == TestGroups::Groups::BAR, + "Must check which() before get()ing a union member."); + return TestGroups::Groups::Bar::Builder(_builder); +} +inline TestGroups::Groups::Bar::Builder TestGroups::Groups::Builder::initBar() { + _builder.setDataField( + 2 * ::capnp::ELEMENTS, TestGroups::Groups::BAR); + _builder.setDataField< ::uint32_t>(0 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(1 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(0 * ::capnp::POINTERS).clear(); + return TestGroups::Groups::Bar::Builder(_builder); +} +inline bool TestGroups::Groups::Foo::Reader::hasCorge() const { + return _reader.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestGroups::Groups::Foo::Builder::hasCorge() { + return _builder.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} +inline ::int32_t TestGroups::Groups::Foo::Reader::getCorge() const { + return _reader.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestGroups::Groups::Foo::Builder::getCorge() { + return _builder.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Foo::Builder::setCorge( ::int32_t value) { + _builder.setDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestGroups::Groups::Foo::Reader::hasGrault() const { + return _reader.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestGroups::Groups::Foo::Builder::hasGrault() { + return _builder.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} +inline ::int64_t TestGroups::Groups::Foo::Reader::getGrault() const { + return _reader.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestGroups::Groups::Foo::Builder::getGrault() { + return _builder.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Foo::Builder::setGrault( ::int64_t value) { + _builder.setDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestGroups::Groups::Foo::Reader::hasGarply() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Foo::Builder::hasGarply() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestGroups::Groups::Foo::Reader::getGarply() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestGroups::Groups::Foo::Builder::getGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestGroups::Groups::Foo::Builder::setGarply( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestGroups::Groups::Foo::Builder::initGarply(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestGroups::Groups::Foo::Builder::adoptGarply( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestGroups::Groups::Foo::Builder::disownGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestGroups::Groups::Baz::Reader::hasCorge() const { + return _reader.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestGroups::Groups::Baz::Builder::hasCorge() { + return _builder.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} +inline ::int32_t TestGroups::Groups::Baz::Reader::getCorge() const { + return _reader.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestGroups::Groups::Baz::Builder::getCorge() { + return _builder.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Baz::Builder::setCorge( ::int32_t value) { + _builder.setDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestGroups::Groups::Baz::Reader::hasGrault() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Baz::Builder::hasGrault() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestGroups::Groups::Baz::Reader::getGrault() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestGroups::Groups::Baz::Builder::getGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestGroups::Groups::Baz::Builder::setGrault( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestGroups::Groups::Baz::Builder::initGrault(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestGroups::Groups::Baz::Builder::adoptGrault( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestGroups::Groups::Baz::Builder::disownGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestGroups::Groups::Baz::Reader::hasGarply() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Baz::Builder::hasGarply() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestGroups::Groups::Baz::Reader::getGarply() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestGroups::Groups::Baz::Builder::getGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestGroups::Groups::Baz::Builder::setGarply( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestGroups::Groups::Baz::Builder::initGarply(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestGroups::Groups::Baz::Builder::adoptGarply( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestGroups::Groups::Baz::Builder::disownGarply() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestGroups::Groups::Bar::Reader::hasCorge() const { + return _reader.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestGroups::Groups::Bar::Builder::hasCorge() { + return _builder.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} +inline ::int32_t TestGroups::Groups::Bar::Reader::getCorge() const { + return _reader.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestGroups::Groups::Bar::Builder::getCorge() { + return _builder.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Bar::Builder::setCorge( ::int32_t value) { + _builder.setDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestGroups::Groups::Bar::Reader::hasGrault() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestGroups::Groups::Bar::Builder::hasGrault() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestGroups::Groups::Bar::Reader::getGrault() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestGroups::Groups::Bar::Builder::getGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestGroups::Groups::Bar::Builder::setGrault( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestGroups::Groups::Bar::Builder::initGrault(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestGroups::Groups::Bar::Builder::adoptGrault( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestGroups::Groups::Bar::Builder::disownGrault() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestGroups::Groups::Bar::Reader::hasGarply() const { + return _reader.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestGroups::Groups::Bar::Builder::hasGarply() { + return _builder.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} +inline ::int64_t TestGroups::Groups::Bar::Reader::getGarply() const { + return _reader.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestGroups::Groups::Bar::Builder::getGarply() { + return _builder.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestGroups::Groups::Bar::Builder::setGarply( ::int64_t value) { + _builder.setDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Reader::hasGroup1() const { + return _reader.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(12 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(14 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(4 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(0 * ::capnp::POINTERS).isNull() + || !_reader.getPointerField(2 * ::capnp::POINTERS).isNull() + || !_reader.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Builder::hasGroup1() { + return _builder.getDataField< ::uint32_t>(0 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(1 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(12 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(14 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(4 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(0 * ::capnp::POINTERS).isNull() + || !_builder.getPointerField(2 * ::capnp::POINTERS).isNull() + || !_builder.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline TestInterleavedGroups::Group1::Reader TestInterleavedGroups::Reader::getGroup1() const { + return TestInterleavedGroups::Group1::Reader(_reader); +} +inline TestInterleavedGroups::Group1::Builder TestInterleavedGroups::Builder::getGroup1() { + return TestInterleavedGroups::Group1::Builder(_builder); +} +inline TestInterleavedGroups::Group1::Pipeline TestInterleavedGroups::Pipeline::getGroup1() const { + return TestInterleavedGroups::Group1::Pipeline(_typeless.noop()); +} +inline TestInterleavedGroups::Group1::Builder TestInterleavedGroups::Builder::initGroup1() { + _builder.setDataField< ::uint32_t>(0 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(1 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(12 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(14 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(4 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(0 * ::capnp::POINTERS).clear(); + _builder.getPointerField(2 * ::capnp::POINTERS).clear(); + _builder.getPointerField(4 * ::capnp::POINTERS).clear(); + return TestInterleavedGroups::Group1::Builder(_builder); +} +inline bool TestInterleavedGroups::Reader::hasGroup2() const { + return _reader.getDataField< ::uint32_t>(1 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(2 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(13 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint16_t>(15 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(5 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(1 * ::capnp::POINTERS).isNull() + || !_reader.getPointerField(3 * ::capnp::POINTERS).isNull() + || !_reader.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Builder::hasGroup2() { + return _builder.getDataField< ::uint32_t>(1 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(2 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(13 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint16_t>(15 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(5 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(1 * ::capnp::POINTERS).isNull() + || !_builder.getPointerField(3 * ::capnp::POINTERS).isNull() + || !_builder.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline TestInterleavedGroups::Group2::Reader TestInterleavedGroups::Reader::getGroup2() const { + return TestInterleavedGroups::Group2::Reader(_reader); +} +inline TestInterleavedGroups::Group2::Builder TestInterleavedGroups::Builder::getGroup2() { + return TestInterleavedGroups::Group2::Builder(_builder); +} +inline TestInterleavedGroups::Group2::Pipeline TestInterleavedGroups::Pipeline::getGroup2() const { + return TestInterleavedGroups::Group2::Pipeline(_typeless.noop()); +} +inline TestInterleavedGroups::Group2::Builder TestInterleavedGroups::Builder::initGroup2() { + _builder.setDataField< ::uint32_t>(1 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(2 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(13 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint16_t>(15 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(5 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(1 * ::capnp::POINTERS).clear(); + _builder.getPointerField(3 * ::capnp::POINTERS).clear(); + _builder.getPointerField(5 * ::capnp::POINTERS).clear(); + return TestInterleavedGroups::Group2::Builder(_builder); +} +inline TestInterleavedGroups::Group1::Which TestInterleavedGroups::Group1::Reader::which() const { + return _reader.getDataField(14 * ::capnp::ELEMENTS); +} +inline TestInterleavedGroups::Group1::Which TestInterleavedGroups::Group1::Builder::which() { + return _builder.getDataField(14 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group1::Reader::hasFoo() const { + return _reader.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group1::Builder::hasFoo() { + return _builder.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestInterleavedGroups::Group1::Reader::getFoo() const { + return _reader.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestInterleavedGroups::Group1::Builder::getFoo() { + return _builder.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Builder::setFoo( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group1::Reader::hasBar() const { + return _reader.hasDataField< ::uint64_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group1::Builder::hasBar() { + return _builder.hasDataField< ::uint64_t>(1 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestInterleavedGroups::Group1::Reader::getBar() const { + return _reader.getDataField< ::uint64_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestInterleavedGroups::Group1::Builder::getBar() { + return _builder.getDataField< ::uint64_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Builder::setBar( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group1::Reader::isQux() const { + return which() == TestInterleavedGroups::Group1::QUX; +} +inline bool TestInterleavedGroups::Group1::Builder::isQux() { + return which() == TestInterleavedGroups::Group1::QUX; +} +inline bool TestInterleavedGroups::Group1::Reader::hasQux() const { + if (which() != TestInterleavedGroups::Group1::QUX) return false; + return _reader.hasDataField< ::uint16_t>(12 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group1::Builder::hasQux() { + if (which() != TestInterleavedGroups::Group1::QUX) return false; + return _builder.hasDataField< ::uint16_t>(12 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestInterleavedGroups::Group1::Reader::getQux() const { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group1::QUX, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint16_t>( + 12 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestInterleavedGroups::Group1::Builder::getQux() { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group1::QUX, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint16_t>( + 12 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Builder::setQux( ::uint16_t value) { + _builder.setDataField( + 14 * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::QUX); + _builder.setDataField< ::uint16_t>( + 12 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group1::Reader::isCorge() const { + return which() == TestInterleavedGroups::Group1::CORGE; +} +inline bool TestInterleavedGroups::Group1::Builder::isCorge() { + return which() == TestInterleavedGroups::Group1::CORGE; +} +inline bool TestInterleavedGroups::Group1::Reader::hasCorge() const { + if (which() != TestInterleavedGroups::Group1::CORGE) return false; + return _reader.getDataField< ::uint16_t>(12 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(4 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(2 * ::capnp::POINTERS).isNull() + || !_reader.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Builder::hasCorge() { + if (which() != TestInterleavedGroups::Group1::CORGE) return false; + return _builder.getDataField< ::uint16_t>(12 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(4 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(2 * ::capnp::POINTERS).isNull() + || !_builder.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline TestInterleavedGroups::Group1::Corge::Reader TestInterleavedGroups::Group1::Reader::getCorge() const { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group1::CORGE, + "Must check which() before get()ing a union member."); + return TestInterleavedGroups::Group1::Corge::Reader(_reader); +} +inline TestInterleavedGroups::Group1::Corge::Builder TestInterleavedGroups::Group1::Builder::getCorge() { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group1::CORGE, + "Must check which() before get()ing a union member."); + return TestInterleavedGroups::Group1::Corge::Builder(_builder); +} +inline TestInterleavedGroups::Group1::Corge::Builder TestInterleavedGroups::Group1::Builder::initCorge() { + _builder.setDataField( + 14 * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::CORGE); + _builder.setDataField< ::uint16_t>(12 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(4 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(2 * ::capnp::POINTERS).clear(); + _builder.getPointerField(4 * ::capnp::POINTERS).clear(); + return TestInterleavedGroups::Group1::Corge::Builder(_builder); +} +inline bool TestInterleavedGroups::Group1::Reader::hasWaldo() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Builder::hasWaldo() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group1::Reader::getWaldo() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Builder::getWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group1::Builder::setWaldo( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Builder::initWaldo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group1::Builder::adoptWaldo( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group1::Builder::disownWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group1::Reader::isFred() const { + return which() == TestInterleavedGroups::Group1::FRED; +} +inline bool TestInterleavedGroups::Group1::Builder::isFred() { + return which() == TestInterleavedGroups::Group1::FRED; +} +inline bool TestInterleavedGroups::Group1::Reader::hasFred() const { + if (which() != TestInterleavedGroups::Group1::FRED) return false; + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Builder::hasFred() { + if (which() != TestInterleavedGroups::Group1::FRED) return false; + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group1::Reader::getFred() const { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group1::FRED, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Builder::getFred() { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group1::FRED, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group1::Builder::setFred( ::capnp::Text::Reader value) { + _builder.setDataField( + 14 * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::FRED); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Builder::initFred(unsigned int size) { + _builder.setDataField( + 14 * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::FRED); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(2 * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group1::Builder::adoptFred( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 14 * ::capnp::ELEMENTS, TestInterleavedGroups::Group1::FRED); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group1::Builder::disownFred() { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group1::FRED, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group1::Corge::Reader::hasGrault() const { + return _reader.hasDataField< ::uint64_t>(4 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group1::Corge::Builder::hasGrault() { + return _builder.hasDataField< ::uint64_t>(4 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestInterleavedGroups::Group1::Corge::Reader::getGrault() const { + return _reader.getDataField< ::uint64_t>( + 4 * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestInterleavedGroups::Group1::Corge::Builder::getGrault() { + return _builder.getDataField< ::uint64_t>( + 4 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::setGrault( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 4 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group1::Corge::Reader::hasGarply() const { + return _reader.hasDataField< ::uint16_t>(12 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group1::Corge::Builder::hasGarply() { + return _builder.hasDataField< ::uint16_t>(12 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestInterleavedGroups::Group1::Corge::Reader::getGarply() const { + return _reader.getDataField< ::uint16_t>( + 12 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestInterleavedGroups::Group1::Corge::Builder::getGarply() { + return _builder.getDataField< ::uint16_t>( + 12 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::setGarply( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + 12 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group1::Corge::Reader::hasPlugh() const { + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Corge::Builder::hasPlugh() { + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group1::Corge::Reader::getPlugh() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Corge::Builder::getPlugh() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::setPlugh( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Corge::Builder::initPlugh(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(2 * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::adoptPlugh( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group1::Corge::Builder::disownPlugh() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group1::Corge::Reader::hasXyzzy() const { + return !_reader.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group1::Corge::Builder::hasXyzzy() { + return !_builder.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group1::Corge::Reader::getXyzzy() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(4 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Corge::Builder::getXyzzy() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::setXyzzy( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(4 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group1::Corge::Builder::initXyzzy(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(4 * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group1::Corge::Builder::adoptXyzzy( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(4 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group1::Corge::Builder::disownXyzzy() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} + +inline TestInterleavedGroups::Group2::Which TestInterleavedGroups::Group2::Reader::which() const { + return _reader.getDataField(15 * ::capnp::ELEMENTS); +} +inline TestInterleavedGroups::Group2::Which TestInterleavedGroups::Group2::Builder::which() { + return _builder.getDataField(15 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group2::Reader::hasFoo() const { + return _reader.hasDataField< ::uint32_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group2::Builder::hasFoo() { + return _builder.hasDataField< ::uint32_t>(1 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestInterleavedGroups::Group2::Reader::getFoo() const { + return _reader.getDataField< ::uint32_t>( + 1 * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestInterleavedGroups::Group2::Builder::getFoo() { + return _builder.getDataField< ::uint32_t>( + 1 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Builder::setFoo( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + 1 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group2::Reader::hasBar() const { + return _reader.hasDataField< ::uint64_t>(2 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group2::Builder::hasBar() { + return _builder.hasDataField< ::uint64_t>(2 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestInterleavedGroups::Group2::Reader::getBar() const { + return _reader.getDataField< ::uint64_t>( + 2 * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestInterleavedGroups::Group2::Builder::getBar() { + return _builder.getDataField< ::uint64_t>( + 2 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Builder::setBar( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 2 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group2::Reader::isQux() const { + return which() == TestInterleavedGroups::Group2::QUX; +} +inline bool TestInterleavedGroups::Group2::Builder::isQux() { + return which() == TestInterleavedGroups::Group2::QUX; +} +inline bool TestInterleavedGroups::Group2::Reader::hasQux() const { + if (which() != TestInterleavedGroups::Group2::QUX) return false; + return _reader.hasDataField< ::uint16_t>(13 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group2::Builder::hasQux() { + if (which() != TestInterleavedGroups::Group2::QUX) return false; + return _builder.hasDataField< ::uint16_t>(13 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestInterleavedGroups::Group2::Reader::getQux() const { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group2::QUX, + "Must check which() before get()ing a union member."); + return _reader.getDataField< ::uint16_t>( + 13 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestInterleavedGroups::Group2::Builder::getQux() { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group2::QUX, + "Must check which() before get()ing a union member."); + return _builder.getDataField< ::uint16_t>( + 13 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Builder::setQux( ::uint16_t value) { + _builder.setDataField( + 15 * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::QUX); + _builder.setDataField< ::uint16_t>( + 13 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group2::Reader::isCorge() const { + return which() == TestInterleavedGroups::Group2::CORGE; +} +inline bool TestInterleavedGroups::Group2::Builder::isCorge() { + return which() == TestInterleavedGroups::Group2::CORGE; +} +inline bool TestInterleavedGroups::Group2::Reader::hasCorge() const { + if (which() != TestInterleavedGroups::Group2::CORGE) return false; + return _reader.getDataField< ::uint16_t>(13 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint64_t>(5 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(3 * ::capnp::POINTERS).isNull() + || !_reader.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Builder::hasCorge() { + if (which() != TestInterleavedGroups::Group2::CORGE) return false; + return _builder.getDataField< ::uint16_t>(13 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint64_t>(5 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(3 * ::capnp::POINTERS).isNull() + || !_builder.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline TestInterleavedGroups::Group2::Corge::Reader TestInterleavedGroups::Group2::Reader::getCorge() const { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group2::CORGE, + "Must check which() before get()ing a union member."); + return TestInterleavedGroups::Group2::Corge::Reader(_reader); +} +inline TestInterleavedGroups::Group2::Corge::Builder TestInterleavedGroups::Group2::Builder::getCorge() { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group2::CORGE, + "Must check which() before get()ing a union member."); + return TestInterleavedGroups::Group2::Corge::Builder(_builder); +} +inline TestInterleavedGroups::Group2::Corge::Builder TestInterleavedGroups::Group2::Builder::initCorge() { + _builder.setDataField( + 15 * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::CORGE); + _builder.setDataField< ::uint16_t>(13 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint64_t>(5 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(3 * ::capnp::POINTERS).clear(); + _builder.getPointerField(5 * ::capnp::POINTERS).clear(); + return TestInterleavedGroups::Group2::Corge::Builder(_builder); +} +inline bool TestInterleavedGroups::Group2::Reader::hasWaldo() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Builder::hasWaldo() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group2::Reader::getWaldo() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Builder::getWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group2::Builder::setWaldo( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Builder::initWaldo(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group2::Builder::adoptWaldo( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group2::Builder::disownWaldo() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group2::Reader::isFred() const { + return which() == TestInterleavedGroups::Group2::FRED; +} +inline bool TestInterleavedGroups::Group2::Builder::isFred() { + return which() == TestInterleavedGroups::Group2::FRED; +} +inline bool TestInterleavedGroups::Group2::Reader::hasFred() const { + if (which() != TestInterleavedGroups::Group2::FRED) return false; + return !_reader.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Builder::hasFred() { + if (which() != TestInterleavedGroups::Group2::FRED) return false; + return !_builder.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group2::Reader::getFred() const { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group2::FRED, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(3 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Builder::getFred() { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group2::FRED, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group2::Builder::setFred( ::capnp::Text::Reader value) { + _builder.setDataField( + 15 * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::FRED); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Builder::initFred(unsigned int size) { + _builder.setDataField( + 15 * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::FRED); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(3 * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group2::Builder::adoptFred( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 15 * ::capnp::ELEMENTS, TestInterleavedGroups::Group2::FRED); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(3 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group2::Builder::disownFred() { + KJ_IREQUIRE(which() == TestInterleavedGroups::Group2::FRED, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group2::Corge::Reader::hasGrault() const { + return _reader.hasDataField< ::uint64_t>(5 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group2::Corge::Builder::hasGrault() { + return _builder.hasDataField< ::uint64_t>(5 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestInterleavedGroups::Group2::Corge::Reader::getGrault() const { + return _reader.getDataField< ::uint64_t>( + 5 * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestInterleavedGroups::Group2::Corge::Builder::getGrault() { + return _builder.getDataField< ::uint64_t>( + 5 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::setGrault( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 5 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group2::Corge::Reader::hasGarply() const { + return _reader.hasDataField< ::uint16_t>(13 * ::capnp::ELEMENTS); +} + +inline bool TestInterleavedGroups::Group2::Corge::Builder::hasGarply() { + return _builder.hasDataField< ::uint16_t>(13 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestInterleavedGroups::Group2::Corge::Reader::getGarply() const { + return _reader.getDataField< ::uint16_t>( + 13 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestInterleavedGroups::Group2::Corge::Builder::getGarply() { + return _builder.getDataField< ::uint16_t>( + 13 * ::capnp::ELEMENTS); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::setGarply( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + 13 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterleavedGroups::Group2::Corge::Reader::hasPlugh() const { + return !_reader.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Corge::Builder::hasPlugh() { + return !_builder.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group2::Corge::Reader::getPlugh() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(3 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Corge::Builder::getPlugh() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::setPlugh( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Corge::Builder::initPlugh(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(3 * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::adoptPlugh( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(3 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group2::Corge::Builder::disownPlugh() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} + +inline bool TestInterleavedGroups::Group2::Corge::Reader::hasXyzzy() const { + return !_reader.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterleavedGroups::Group2::Corge::Builder::hasXyzzy() { + return !_builder.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterleavedGroups::Group2::Corge::Reader::getXyzzy() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(5 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Corge::Builder::getXyzzy() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::setXyzzy( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(5 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterleavedGroups::Group2::Corge::Builder::initXyzzy(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(5 * ::capnp::POINTERS), size); +} +inline void TestInterleavedGroups::Group2::Corge::Builder::adoptXyzzy( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(5 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterleavedGroups::Group2::Corge::Builder::disownXyzzy() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} + +inline bool TestUnionDefaults::Reader::hasS16s8s64s8Set() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnionDefaults::Builder::hasS16s8s64s8Set() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUnion::Reader TestUnionDefaults::Reader::getS16s8s64s8Set() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::get( + _reader.getPointerField(0 * ::capnp::POINTERS), + ::capnp::schemas::s_94f7e0b103b4b718.encodedNode + 53); +} +inline ::capnproto_test::capnp::test::TestUnion::Builder TestUnionDefaults::Builder::getS16s8s64s8Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::get( + _builder.getPointerField(0 * ::capnp::POINTERS), + ::capnp::schemas::s_94f7e0b103b4b718.encodedNode + 53); +} +inline ::capnproto_test::capnp::test::TestUnion::Pipeline TestUnionDefaults::Pipeline::getS16s8s64s8Set() const { + return ::capnproto_test::capnp::test::TestUnion::Pipeline(_typeless.getPointerField(0)); +} +inline void TestUnionDefaults::Builder::setS16s8s64s8Set( ::capnproto_test::capnp::test::TestUnion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUnion::Builder TestUnionDefaults::Builder::initS16s8s64s8Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::init( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestUnionDefaults::Builder::adoptS16s8s64s8Set( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion> TestUnionDefaults::Builder::disownS16s8s64s8Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestUnionDefaults::Reader::hasS0sps1s32Set() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnionDefaults::Builder::hasS0sps1s32Set() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUnion::Reader TestUnionDefaults::Reader::getS0sps1s32Set() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::get( + _reader.getPointerField(1 * ::capnp::POINTERS), + ::capnp::schemas::s_94f7e0b103b4b718.encodedNode + 71); +} +inline ::capnproto_test::capnp::test::TestUnion::Builder TestUnionDefaults::Builder::getS0sps1s32Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::get( + _builder.getPointerField(1 * ::capnp::POINTERS), + ::capnp::schemas::s_94f7e0b103b4b718.encodedNode + 71); +} +inline ::capnproto_test::capnp::test::TestUnion::Pipeline TestUnionDefaults::Pipeline::getS0sps1s32Set() const { + return ::capnproto_test::capnp::test::TestUnion::Pipeline(_typeless.getPointerField(1)); +} +inline void TestUnionDefaults::Builder::setS0sps1s32Set( ::capnproto_test::capnp::test::TestUnion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUnion::Builder TestUnionDefaults::Builder::initS0sps1s32Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::init( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestUnionDefaults::Builder::adoptS0sps1s32Set( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnion> TestUnionDefaults::Builder::disownS0sps1s32Set() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnion>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestUnionDefaults::Reader::hasUnnamed1() const { + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnionDefaults::Builder::hasUnnamed1() { + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Reader TestUnionDefaults::Reader::getUnnamed1() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::get( + _reader.getPointerField(2 * ::capnp::POINTERS), + ::capnp::schemas::s_94f7e0b103b4b718.encodedNode + 90); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder TestUnionDefaults::Builder::getUnnamed1() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::get( + _builder.getPointerField(2 * ::capnp::POINTERS), + ::capnp::schemas::s_94f7e0b103b4b718.encodedNode + 90); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline TestUnionDefaults::Pipeline::getUnnamed1() const { + return ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline(_typeless.getPointerField(2)); +} +inline void TestUnionDefaults::Builder::setUnnamed1( ::capnproto_test::capnp::test::TestUnnamedUnion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder TestUnionDefaults::Builder::initUnnamed1() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::init( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestUnionDefaults::Builder::adoptUnnamed1( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion> TestUnionDefaults::Builder::disownUnnamed1() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestUnionDefaults::Reader::hasUnnamed2() const { + return !_reader.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline bool TestUnionDefaults::Builder::hasUnnamed2() { + return !_builder.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Reader TestUnionDefaults::Reader::getUnnamed2() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::get( + _reader.getPointerField(3 * ::capnp::POINTERS), + ::capnp::schemas::s_94f7e0b103b4b718.encodedNode + 102); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder TestUnionDefaults::Builder::getUnnamed2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::get( + _builder.getPointerField(3 * ::capnp::POINTERS), + ::capnp::schemas::s_94f7e0b103b4b718.encodedNode + 102); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline TestUnionDefaults::Pipeline::getUnnamed2() const { + return ::capnproto_test::capnp::test::TestUnnamedUnion::Pipeline(_typeless.getPointerField(3)); +} +inline void TestUnionDefaults::Builder::setUnnamed2( ::capnproto_test::capnp::test::TestUnnamedUnion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestUnnamedUnion::Builder TestUnionDefaults::Builder::initUnnamed2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::init( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} +inline void TestUnionDefaults::Builder::adoptUnnamed2( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::adopt( + _builder.getPointerField(3 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestUnnamedUnion> TestUnionDefaults::Builder::disownUnnamed2() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestUnnamedUnion>::disown( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} + +inline bool TestNestedTypes::Reader::hasNestedStruct() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestNestedTypes::Builder::hasNestedStruct() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Reader TestNestedTypes::Reader::getNestedStruct() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Builder TestNestedTypes::Builder::getNestedStruct() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Pipeline TestNestedTypes::Pipeline::getNestedStruct() const { + return ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Pipeline(_typeless.getPointerField(0)); +} +inline void TestNestedTypes::Builder::setNestedStruct( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::Builder TestNestedTypes::Builder::initNestedStruct() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::init( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestNestedTypes::Builder::adoptNestedStruct( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct> TestNestedTypes::Builder::disownNestedStruct() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestNestedTypes::Reader::hasOuterNestedEnum() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>(0 * ::capnp::ELEMENTS); +} + +inline bool TestNestedTypes::Builder::hasOuterNestedEnum() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>(0 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestNestedTypes::Reader::getOuterNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 0 * ::capnp::ELEMENTS, 1u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestNestedTypes::Builder::getOuterNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 0 * ::capnp::ELEMENTS, 1u); +} +inline void TestNestedTypes::Builder::setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 0 * ::capnp::ELEMENTS, value, 1u); +} + +inline bool TestNestedTypes::Reader::hasInnerNestedEnum() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>(1 * ::capnp::ELEMENTS); +} + +inline bool TestNestedTypes::Builder::hasInnerNestedEnum() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>(1 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestNestedTypes::Reader::getInnerNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 1 * ::capnp::ELEMENTS, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestNestedTypes::Builder::getInnerNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 1 * ::capnp::ELEMENTS, 2u); +} +inline void TestNestedTypes::Builder::setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 1 * ::capnp::ELEMENTS, value, 2u); +} + +inline bool TestNestedTypes::NestedStruct::Reader::hasOuterNestedEnum() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>(0 * ::capnp::ELEMENTS); +} + +inline bool TestNestedTypes::NestedStruct::Builder::hasOuterNestedEnum() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>(0 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestNestedTypes::NestedStruct::Reader::getOuterNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 0 * ::capnp::ELEMENTS, 1u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestNestedTypes::NestedStruct::Builder::getOuterNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 0 * ::capnp::ELEMENTS, 1u); +} +inline void TestNestedTypes::NestedStruct::Builder::setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 0 * ::capnp::ELEMENTS, value, 1u); +} + +inline bool TestNestedTypes::NestedStruct::Reader::hasInnerNestedEnum() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>(1 * ::capnp::ELEMENTS); +} + +inline bool TestNestedTypes::NestedStruct::Builder::hasInnerNestedEnum() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>(1 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestNestedTypes::NestedStruct::Reader::getInnerNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 1 * ::capnp::ELEMENTS, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestNestedTypes::NestedStruct::Builder::getInnerNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 1 * ::capnp::ELEMENTS, 2u); +} +inline void TestNestedTypes::NestedStruct::Builder::setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 1 * ::capnp::ELEMENTS, value, 2u); +} + +inline bool TestUsing::Reader::hasInnerNestedEnum() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>(0 * ::capnp::ELEMENTS); +} + +inline bool TestUsing::Builder::hasInnerNestedEnum() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>(0 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestUsing::Reader::getInnerNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 0 * ::capnp::ELEMENTS, 2u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum TestUsing::Builder::getInnerNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 0 * ::capnp::ELEMENTS, 2u); +} +inline void TestUsing::Builder::setInnerNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedStruct::NestedEnum>( + 0 * ::capnp::ELEMENTS, value, 2u); +} + +inline bool TestUsing::Reader::hasOuterNestedEnum() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>(1 * ::capnp::ELEMENTS); +} + +inline bool TestUsing::Builder::hasOuterNestedEnum() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>(1 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestUsing::Reader::getOuterNestedEnum() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 1 * ::capnp::ELEMENTS, 1u); +} + +inline ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum TestUsing::Builder::getOuterNestedEnum() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 1 * ::capnp::ELEMENTS, 1u); +} +inline void TestUsing::Builder::setOuterNestedEnum( ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestNestedTypes::NestedEnum>( + 1 * ::capnp::ELEMENTS, value, 1u); +} + +inline bool TestLists::Reader::hasList0() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList0() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>::Reader TestLists::Reader::getList0() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>::Builder TestLists::Builder::getList0() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList0( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>::Builder TestLists::Builder::initList0(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList0( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>> TestLists::Builder::disownList0() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct0>>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList1() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList1() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>::Reader TestLists::Reader::getList1() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>::Builder TestLists::Builder::getList1() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList1( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>::Builder TestLists::Builder::initList1(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList1( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>> TestLists::Builder::disownList1() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct1>>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList8() const { + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList8() { + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>::Reader TestLists::Reader::getList8() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>>::get( + _reader.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>::Builder TestLists::Builder::getList8() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>>::get( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList8( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>::Builder TestLists::Builder::initList8(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>>::init( + _builder.getPointerField(2 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList8( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>> TestLists::Builder::disownList8() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct8>>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList16() const { + return !_reader.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList16() { + return !_builder.getPointerField(3 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>::Reader TestLists::Reader::getList16() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>>::get( + _reader.getPointerField(3 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>::Builder TestLists::Builder::getList16() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>>::get( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList16( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>>::set( + _builder.getPointerField(3 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>::Builder TestLists::Builder::initList16(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>>::init( + _builder.getPointerField(3 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList16( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>>::adopt( + _builder.getPointerField(3 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>> TestLists::Builder::disownList16() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct16>>::disown( + _builder.getPointerField(3 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList32() const { + return !_reader.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList32() { + return !_builder.getPointerField(4 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>::Reader TestLists::Reader::getList32() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>>::get( + _reader.getPointerField(4 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>::Builder TestLists::Builder::getList32() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>>::get( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList32( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>>::set( + _builder.getPointerField(4 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>::Builder TestLists::Builder::initList32(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>>::init( + _builder.getPointerField(4 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList32( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>>::adopt( + _builder.getPointerField(4 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>> TestLists::Builder::disownList32() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct32>>::disown( + _builder.getPointerField(4 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasList64() const { + return !_reader.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasList64() { + return !_builder.getPointerField(5 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>::Reader TestLists::Reader::getList64() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>>::get( + _reader.getPointerField(5 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>::Builder TestLists::Builder::getList64() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>>::get( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setList64( ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>>::set( + _builder.getPointerField(5 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>::Builder TestLists::Builder::initList64(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>>::init( + _builder.getPointerField(5 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptList64( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>>::adopt( + _builder.getPointerField(5 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>> TestLists::Builder::disownList64() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::Struct64>>::disown( + _builder.getPointerField(5 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasListP() const { + return !_reader.getPointerField(6 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasListP() { + return !_builder.getPointerField(6 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>::Reader TestLists::Reader::getListP() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>>::get( + _reader.getPointerField(6 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>::Builder TestLists::Builder::getListP() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>>::get( + _builder.getPointerField(6 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setListP( ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>>::set( + _builder.getPointerField(6 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>::Builder TestLists::Builder::initListP(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>>::init( + _builder.getPointerField(6 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptListP( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>>::adopt( + _builder.getPointerField(6 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>> TestLists::Builder::disownListP() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestLists::StructP>>::disown( + _builder.getPointerField(6 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasInt32ListList() const { + return !_reader.getPointerField(7 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasInt32ListList() { + return !_builder.getPointerField(7 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::int32_t>>::Reader TestLists::Reader::getInt32ListList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t>>>::get( + _reader.getPointerField(7 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::int32_t>>::Builder TestLists::Builder::getInt32ListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t>>>::get( + _builder.getPointerField(7 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setInt32ListList( ::capnp::List< ::capnp::List< ::int32_t>>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t>>>::set( + _builder.getPointerField(7 * ::capnp::POINTERS), value); +} +inline void TestLists::Builder::setInt32ListList(std::initializer_list< ::capnp::List< ::int32_t>::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t>>>::set( + _builder.getPointerField(7 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::int32_t>>::Builder TestLists::Builder::initInt32ListList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t>>>::init( + _builder.getPointerField(7 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptInt32ListList( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::int32_t>>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t>>>::adopt( + _builder.getPointerField(7 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::int32_t>>> TestLists::Builder::disownInt32ListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::int32_t>>>::disown( + _builder.getPointerField(7 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasTextListList() const { + return !_reader.getPointerField(8 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasTextListList() { + return !_builder.getPointerField(8 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text>>::Reader TestLists::Reader::getTextListList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text>>>::get( + _reader.getPointerField(8 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text>>::Builder TestLists::Builder::getTextListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text>>>::get( + _builder.getPointerField(8 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setTextListList( ::capnp::List< ::capnp::List< ::capnp::Text>>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text>>>::set( + _builder.getPointerField(8 * ::capnp::POINTERS), value); +} +inline void TestLists::Builder::setTextListList(std::initializer_list< ::capnp::List< ::capnp::Text>::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text>>>::set( + _builder.getPointerField(8 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::capnp::Text>>::Builder TestLists::Builder::initTextListList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text>>>::init( + _builder.getPointerField(8 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptTextListList( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text>>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text>>>::adopt( + _builder.getPointerField(8 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::Text>>> TestLists::Builder::disownTextListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::Text>>>::disown( + _builder.getPointerField(8 * ::capnp::POINTERS)); +} + +inline bool TestLists::Reader::hasStructListList() const { + return !_reader.getPointerField(9 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Builder::hasStructListList() { + return !_builder.getPointerField(9 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::Reader TestLists::Reader::getStructListList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>::get( + _reader.getPointerField(9 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::Builder TestLists::Builder::getStructListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>::get( + _builder.getPointerField(9 * ::capnp::POINTERS)); +} +inline void TestLists::Builder::setStructListList( ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>::set( + _builder.getPointerField(9 * ::capnp::POINTERS), value); +} +inline void TestLists::Builder::setStructListList(std::initializer_list< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>::Reader> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>::set( + _builder.getPointerField(9 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>::Builder TestLists::Builder::initStructListList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>::init( + _builder.getPointerField(9 * ::capnp::POINTERS), size); +} +inline void TestLists::Builder::adoptStructListList( + ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>::adopt( + _builder.getPointerField(9 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>> TestLists::Builder::disownStructListList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnproto_test::capnp::test::TestAllTypes>>>::disown( + _builder.getPointerField(9 * ::capnp::POINTERS)); +} + +inline bool TestLists::Struct0::Reader::hasF() const { + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct0::Builder::hasF() { + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestLists::Struct0::Reader::getF() const { + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestLists::Struct0::Builder::getF() { + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct0::Builder::setF( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct1::Reader::hasF() const { + return _reader.hasDataField(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct1::Builder::hasF() { + return _builder.hasDataField(0 * ::capnp::ELEMENTS); +} +inline bool TestLists::Struct1::Reader::getF() const { + return _reader.getDataField( + 0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct1::Builder::getF() { + return _builder.getDataField( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct1::Builder::setF(bool value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct8::Reader::hasF() const { + return _reader.hasDataField< ::uint8_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct8::Builder::hasF() { + return _builder.hasDataField< ::uint8_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint8_t TestLists::Struct8::Reader::getF() const { + return _reader.getDataField< ::uint8_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint8_t TestLists::Struct8::Builder::getF() { + return _builder.getDataField< ::uint8_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct8::Builder::setF( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct16::Reader::hasF() const { + return _reader.hasDataField< ::uint16_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct16::Builder::hasF() { + return _builder.hasDataField< ::uint16_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestLists::Struct16::Reader::getF() const { + return _reader.getDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestLists::Struct16::Builder::getF() { + return _builder.getDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct16::Builder::setF( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct32::Reader::hasF() const { + return _reader.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct32::Builder::hasF() { + return _builder.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestLists::Struct32::Reader::getF() const { + return _reader.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestLists::Struct32::Builder::getF() { + return _builder.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct32::Builder::setF( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct64::Reader::hasF() const { + return _reader.hasDataField< ::uint64_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct64::Builder::hasF() { + return _builder.hasDataField< ::uint64_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestLists::Struct64::Reader::getF() const { + return _reader.getDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestLists::Struct64::Builder::getF() { + return _builder.getDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct64::Builder::setF( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::StructP::Reader::hasF() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::StructP::Builder::hasF() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::StructP::Reader::getF() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::StructP::Builder::getF() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::StructP::Builder::setF( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::StructP::Builder::initF(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::StructP::Builder::adoptF( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::StructP::Builder::disownF() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::Struct0c::Reader::hasF() const { + return _reader.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct0c::Builder::hasF() { + return _builder.hasDataField< ::capnp::Void>(0 * ::capnp::ELEMENTS); +} +inline ::capnp::Void TestLists::Struct0c::Reader::getF() const { + return _reader.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnp::Void TestLists::Struct0c::Builder::getF() { + return _builder.getDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct0c::Builder::setF( ::capnp::Void value) { + _builder.setDataField< ::capnp::Void>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct0c::Reader::hasPad() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct0c::Builder::hasPad() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct0c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct0c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::Struct0c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct0c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::Struct0c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct0c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::Struct1c::Reader::hasF() const { + return _reader.hasDataField(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct1c::Builder::hasF() { + return _builder.hasDataField(0 * ::capnp::ELEMENTS); +} +inline bool TestLists::Struct1c::Reader::getF() const { + return _reader.getDataField( + 0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct1c::Builder::getF() { + return _builder.getDataField( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct1c::Builder::setF(bool value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct1c::Reader::hasPad() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct1c::Builder::hasPad() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct1c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct1c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::Struct1c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct1c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::Struct1c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct1c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::Struct8c::Reader::hasF() const { + return _reader.hasDataField< ::uint8_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct8c::Builder::hasF() { + return _builder.hasDataField< ::uint8_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint8_t TestLists::Struct8c::Reader::getF() const { + return _reader.getDataField< ::uint8_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint8_t TestLists::Struct8c::Builder::getF() { + return _builder.getDataField< ::uint8_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct8c::Builder::setF( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct8c::Reader::hasPad() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct8c::Builder::hasPad() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct8c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct8c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::Struct8c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct8c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::Struct8c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct8c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::Struct16c::Reader::hasF() const { + return _reader.hasDataField< ::uint16_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct16c::Builder::hasF() { + return _builder.hasDataField< ::uint16_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint16_t TestLists::Struct16c::Reader::getF() const { + return _reader.getDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint16_t TestLists::Struct16c::Builder::getF() { + return _builder.getDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct16c::Builder::setF( ::uint16_t value) { + _builder.setDataField< ::uint16_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct16c::Reader::hasPad() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct16c::Builder::hasPad() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct16c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct16c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::Struct16c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct16c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::Struct16c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct16c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::Struct32c::Reader::hasF() const { + return _reader.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct32c::Builder::hasF() { + return _builder.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestLists::Struct32c::Reader::getF() const { + return _reader.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestLists::Struct32c::Builder::getF() { + return _builder.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct32c::Builder::setF( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct32c::Reader::hasPad() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct32c::Builder::hasPad() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct32c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct32c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::Struct32c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct32c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::Struct32c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct32c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::Struct64c::Reader::hasF() const { + return _reader.hasDataField< ::uint64_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::Struct64c::Builder::hasF() { + return _builder.hasDataField< ::uint64_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestLists::Struct64c::Reader::getF() const { + return _reader.getDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestLists::Struct64c::Builder::getF() { + return _builder.getDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::Struct64c::Builder::setF( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLists::Struct64c::Reader::hasPad() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::Struct64c::Builder::hasPad() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::Struct64c::Reader::getPad() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::Struct64c::Builder::getPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::Struct64c::Builder::setPad( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::Struct64c::Builder::initPad(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::Struct64c::Builder::adoptPad( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::Struct64c::Builder::disownPad() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::StructPc::Reader::hasF() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLists::StructPc::Builder::hasF() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLists::StructPc::Reader::getF() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLists::StructPc::Builder::getF() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLists::StructPc::Builder::setF( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLists::StructPc::Builder::initF(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLists::StructPc::Builder::adoptF( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLists::StructPc::Builder::disownF() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLists::StructPc::Reader::hasPad() const { + return _reader.hasDataField< ::uint64_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLists::StructPc::Builder::hasPad() { + return _builder.hasDataField< ::uint64_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint64_t TestLists::StructPc::Reader::getPad() const { + return _reader.getDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint64_t TestLists::StructPc::Builder::getPad() { + return _builder.getDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLists::StructPc::Builder::setPad( ::uint64_t value) { + _builder.setDataField< ::uint64_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestFieldZeroIsBit::Reader::hasBit() const { + return _reader.hasDataField(0 * ::capnp::ELEMENTS); +} + +inline bool TestFieldZeroIsBit::Builder::hasBit() { + return _builder.hasDataField(0 * ::capnp::ELEMENTS); +} +inline bool TestFieldZeroIsBit::Reader::getBit() const { + return _reader.getDataField( + 0 * ::capnp::ELEMENTS); +} + +inline bool TestFieldZeroIsBit::Builder::getBit() { + return _builder.getDataField( + 0 * ::capnp::ELEMENTS); +} +inline void TestFieldZeroIsBit::Builder::setBit(bool value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestFieldZeroIsBit::Reader::hasSecondBit() const { + return _reader.hasDataField(1 * ::capnp::ELEMENTS); +} + +inline bool TestFieldZeroIsBit::Builder::hasSecondBit() { + return _builder.hasDataField(1 * ::capnp::ELEMENTS); +} +inline bool TestFieldZeroIsBit::Reader::getSecondBit() const { + return _reader.getDataField( + 1 * ::capnp::ELEMENTS, true); +} + +inline bool TestFieldZeroIsBit::Builder::getSecondBit() { + return _builder.getDataField( + 1 * ::capnp::ELEMENTS, true); +} +inline void TestFieldZeroIsBit::Builder::setSecondBit(bool value) { + _builder.setDataField( + 1 * ::capnp::ELEMENTS, value, true); +} + +inline bool TestFieldZeroIsBit::Reader::hasThirdField() const { + return _reader.hasDataField< ::uint8_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestFieldZeroIsBit::Builder::hasThirdField() { + return _builder.hasDataField< ::uint8_t>(1 * ::capnp::ELEMENTS); +} +inline ::uint8_t TestFieldZeroIsBit::Reader::getThirdField() const { + return _reader.getDataField< ::uint8_t>( + 1 * ::capnp::ELEMENTS, 123u); +} + +inline ::uint8_t TestFieldZeroIsBit::Builder::getThirdField() { + return _builder.getDataField< ::uint8_t>( + 1 * ::capnp::ELEMENTS, 123u); +} +inline void TestFieldZeroIsBit::Builder::setThirdField( ::uint8_t value) { + _builder.setDataField< ::uint8_t>( + 1 * ::capnp::ELEMENTS, value, 123u); +} + +inline bool TestListDefaults::Reader::hasLists() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestListDefaults::Builder::hasLists() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestLists::Reader TestListDefaults::Reader::getLists() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::get( + _reader.getPointerField(0 * ::capnp::POINTERS), + ::capnp::schemas::s_a851ad32cbc2ffea.encodedNode + 31); +} +inline ::capnproto_test::capnp::test::TestLists::Builder TestListDefaults::Builder::getLists() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::get( + _builder.getPointerField(0 * ::capnp::POINTERS), + ::capnp::schemas::s_a851ad32cbc2ffea.encodedNode + 31); +} +inline ::capnproto_test::capnp::test::TestLists::Pipeline TestListDefaults::Pipeline::getLists() const { + return ::capnproto_test::capnp::test::TestLists::Pipeline(_typeless.getPointerField(0)); +} +inline void TestListDefaults::Builder::setLists( ::capnproto_test::capnp::test::TestLists::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestLists::Builder TestListDefaults::Builder::initLists() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::init( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestListDefaults::Builder::adoptLists( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestLists>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestLists> TestListDefaults::Builder::disownLists() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestLists>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::Reader::hasFoo() const { + return _reader.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestLateUnion::Builder::hasFoo() { + return _builder.hasDataField< ::int32_t>(0 * ::capnp::ELEMENTS); +} +inline ::int32_t TestLateUnion::Reader::getFoo() const { + return _reader.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int32_t TestLateUnion::Builder::getFoo() { + return _builder.getDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestLateUnion::Builder::setFoo( ::int32_t value) { + _builder.setDataField< ::int32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestLateUnion::Reader::hasBar() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::Builder::hasBar() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLateUnion::Reader::getBar() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLateUnion::Builder::getBar() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestLateUnion::Builder::setBar( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLateUnion::Builder::initBar(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestLateUnion::Builder::adoptBar( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLateUnion::Builder::disownBar() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::Reader::hasBaz() const { + return _reader.hasDataField< ::int16_t>(2 * ::capnp::ELEMENTS); +} + +inline bool TestLateUnion::Builder::hasBaz() { + return _builder.hasDataField< ::int16_t>(2 * ::capnp::ELEMENTS); +} +inline ::int16_t TestLateUnion::Reader::getBaz() const { + return _reader.getDataField< ::int16_t>( + 2 * ::capnp::ELEMENTS); +} + +inline ::int16_t TestLateUnion::Builder::getBaz() { + return _builder.getDataField< ::int16_t>( + 2 * ::capnp::ELEMENTS); +} +inline void TestLateUnion::Builder::setBaz( ::int16_t value) { + _builder.setDataField< ::int16_t>( + 2 * ::capnp::ELEMENTS, value); +} + +inline bool TestLateUnion::Reader::hasTheUnion() const { + return _reader.getDataField< ::uint16_t>(3 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint32_t>(2 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::Builder::hasTheUnion() { + return _builder.getDataField< ::uint16_t>(3 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint32_t>(2 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline TestLateUnion::TheUnion::Reader TestLateUnion::Reader::getTheUnion() const { + return TestLateUnion::TheUnion::Reader(_reader); +} +inline TestLateUnion::TheUnion::Builder TestLateUnion::Builder::getTheUnion() { + return TestLateUnion::TheUnion::Builder(_builder); +} +inline TestLateUnion::TheUnion::Pipeline TestLateUnion::Pipeline::getTheUnion() const { + return TestLateUnion::TheUnion::Pipeline(_typeless.noop()); +} +inline TestLateUnion::TheUnion::Builder TestLateUnion::Builder::initTheUnion() { + _builder.setDataField< ::uint16_t>(3 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(2 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(1 * ::capnp::POINTERS).clear(); + return TestLateUnion::TheUnion::Builder(_builder); +} +inline bool TestLateUnion::Reader::hasAnotherUnion() const { + return _reader.getDataField< ::uint16_t>(6 * ::capnp::ELEMENTS) != 0 + || _reader.getDataField< ::uint32_t>(4 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::Builder::hasAnotherUnion() { + return _builder.getDataField< ::uint16_t>(6 * ::capnp::ELEMENTS) != 0 + || _builder.getDataField< ::uint32_t>(4 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline TestLateUnion::AnotherUnion::Reader TestLateUnion::Reader::getAnotherUnion() const { + return TestLateUnion::AnotherUnion::Reader(_reader); +} +inline TestLateUnion::AnotherUnion::Builder TestLateUnion::Builder::getAnotherUnion() { + return TestLateUnion::AnotherUnion::Builder(_builder); +} +inline TestLateUnion::AnotherUnion::Pipeline TestLateUnion::Pipeline::getAnotherUnion() const { + return TestLateUnion::AnotherUnion::Pipeline(_typeless.noop()); +} +inline TestLateUnion::AnotherUnion::Builder TestLateUnion::Builder::initAnotherUnion() { + _builder.setDataField< ::uint16_t>(6 * ::capnp::ELEMENTS, 0); + _builder.setDataField< ::uint32_t>(4 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(2 * ::capnp::POINTERS).clear(); + return TestLateUnion::AnotherUnion::Builder(_builder); +} +inline TestLateUnion::TheUnion::Which TestLateUnion::TheUnion::Reader::which() const { + return _reader.getDataField(3 * ::capnp::ELEMENTS); +} +inline TestLateUnion::TheUnion::Which TestLateUnion::TheUnion::Builder::which() { + return _builder.getDataField(3 * ::capnp::ELEMENTS); +} + +inline bool TestLateUnion::TheUnion::Reader::isQux() const { + return which() == TestLateUnion::TheUnion::QUX; +} +inline bool TestLateUnion::TheUnion::Builder::isQux() { + return which() == TestLateUnion::TheUnion::QUX; +} +inline bool TestLateUnion::TheUnion::Reader::hasQux() const { + if (which() != TestLateUnion::TheUnion::QUX) return false; + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::TheUnion::Builder::hasQux() { + if (which() != TestLateUnion::TheUnion::QUX) return false; + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLateUnion::TheUnion::Reader::getQux() const { + KJ_IREQUIRE(which() == TestLateUnion::TheUnion::QUX, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLateUnion::TheUnion::Builder::getQux() { + KJ_IREQUIRE(which() == TestLateUnion::TheUnion::QUX, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestLateUnion::TheUnion::Builder::setQux( ::capnp::Text::Reader value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestLateUnion::TheUnion::QUX); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLateUnion::TheUnion::Builder::initQux(unsigned int size) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestLateUnion::TheUnion::QUX); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestLateUnion::TheUnion::Builder::adoptQux( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestLateUnion::TheUnion::QUX); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLateUnion::TheUnion::Builder::disownQux() { + KJ_IREQUIRE(which() == TestLateUnion::TheUnion::QUX, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::TheUnion::Reader::isCorge() const { + return which() == TestLateUnion::TheUnion::CORGE; +} +inline bool TestLateUnion::TheUnion::Builder::isCorge() { + return which() == TestLateUnion::TheUnion::CORGE; +} +inline bool TestLateUnion::TheUnion::Reader::hasCorge() const { + if (which() != TestLateUnion::TheUnion::CORGE) return false; + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::TheUnion::Builder::hasCorge() { + if (which() != TestLateUnion::TheUnion::CORGE) return false; + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t>::Reader TestLateUnion::TheUnion::Reader::getCorge() const { + KJ_IREQUIRE(which() == TestLateUnion::TheUnion::CORGE, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int32_t>::Builder TestLateUnion::TheUnion::Builder::getCorge() { + KJ_IREQUIRE(which() == TestLateUnion::TheUnion::CORGE, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestLateUnion::TheUnion::Builder::setCorge( ::capnp::List< ::int32_t>::Reader value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestLateUnion::TheUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline void TestLateUnion::TheUnion::Builder::setCorge(std::initializer_list< ::int32_t> value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestLateUnion::TheUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t>::Builder TestLateUnion::TheUnion::Builder::initCorge(unsigned int size) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestLateUnion::TheUnion::CORGE); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::init( + _builder.getPointerField(1 * ::capnp::POINTERS), size); +} +inline void TestLateUnion::TheUnion::Builder::adoptCorge( + ::capnp::Orphan< ::capnp::List< ::int32_t>>&& value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestLateUnion::TheUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int32_t>> TestLateUnion::TheUnion::Builder::disownCorge() { + KJ_IREQUIRE(which() == TestLateUnion::TheUnion::CORGE, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::TheUnion::Reader::isGrault() const { + return which() == TestLateUnion::TheUnion::GRAULT; +} +inline bool TestLateUnion::TheUnion::Builder::isGrault() { + return which() == TestLateUnion::TheUnion::GRAULT; +} +inline bool TestLateUnion::TheUnion::Reader::hasGrault() const { + if (which() != TestLateUnion::TheUnion::GRAULT) return false; + return _reader.hasDataField(2 * ::capnp::ELEMENTS); +} + +inline bool TestLateUnion::TheUnion::Builder::hasGrault() { + if (which() != TestLateUnion::TheUnion::GRAULT) return false; + return _builder.hasDataField(2 * ::capnp::ELEMENTS); +} +inline float TestLateUnion::TheUnion::Reader::getGrault() const { + KJ_IREQUIRE(which() == TestLateUnion::TheUnion::GRAULT, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 2 * ::capnp::ELEMENTS); +} + +inline float TestLateUnion::TheUnion::Builder::getGrault() { + KJ_IREQUIRE(which() == TestLateUnion::TheUnion::GRAULT, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 2 * ::capnp::ELEMENTS); +} +inline void TestLateUnion::TheUnion::Builder::setGrault(float value) { + _builder.setDataField( + 3 * ::capnp::ELEMENTS, TestLateUnion::TheUnion::GRAULT); + _builder.setDataField( + 2 * ::capnp::ELEMENTS, value); +} + +inline TestLateUnion::AnotherUnion::Which TestLateUnion::AnotherUnion::Reader::which() const { + return _reader.getDataField(6 * ::capnp::ELEMENTS); +} +inline TestLateUnion::AnotherUnion::Which TestLateUnion::AnotherUnion::Builder::which() { + return _builder.getDataField(6 * ::capnp::ELEMENTS); +} + +inline bool TestLateUnion::AnotherUnion::Reader::isQux() const { + return which() == TestLateUnion::AnotherUnion::QUX; +} +inline bool TestLateUnion::AnotherUnion::Builder::isQux() { + return which() == TestLateUnion::AnotherUnion::QUX; +} +inline bool TestLateUnion::AnotherUnion::Reader::hasQux() const { + if (which() != TestLateUnion::AnotherUnion::QUX) return false; + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::AnotherUnion::Builder::hasQux() { + if (which() != TestLateUnion::AnotherUnion::QUX) return false; + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestLateUnion::AnotherUnion::Reader::getQux() const { + KJ_IREQUIRE(which() == TestLateUnion::AnotherUnion::QUX, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestLateUnion::AnotherUnion::Builder::getQux() { + KJ_IREQUIRE(which() == TestLateUnion::AnotherUnion::QUX, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestLateUnion::AnotherUnion::Builder::setQux( ::capnp::Text::Reader value) { + _builder.setDataField( + 6 * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::QUX); + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestLateUnion::AnotherUnion::Builder::initQux(unsigned int size) { + _builder.setDataField( + 6 * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::QUX); + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(2 * ::capnp::POINTERS), size); +} +inline void TestLateUnion::AnotherUnion::Builder::adoptQux( + ::capnp::Orphan< ::capnp::Text>&& value) { + _builder.setDataField( + 6 * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::QUX); + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestLateUnion::AnotherUnion::Builder::disownQux() { + KJ_IREQUIRE(which() == TestLateUnion::AnotherUnion::QUX, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::AnotherUnion::Reader::isCorge() const { + return which() == TestLateUnion::AnotherUnion::CORGE; +} +inline bool TestLateUnion::AnotherUnion::Builder::isCorge() { + return which() == TestLateUnion::AnotherUnion::CORGE; +} +inline bool TestLateUnion::AnotherUnion::Reader::hasCorge() const { + if (which() != TestLateUnion::AnotherUnion::CORGE) return false; + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestLateUnion::AnotherUnion::Builder::hasCorge() { + if (which() != TestLateUnion::AnotherUnion::CORGE) return false; + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::int32_t>::Reader TestLateUnion::AnotherUnion::Reader::getCorge() const { + KJ_IREQUIRE(which() == TestLateUnion::AnotherUnion::CORGE, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::get( + _reader.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::int32_t>::Builder TestLateUnion::AnotherUnion::Builder::getCorge() { + KJ_IREQUIRE(which() == TestLateUnion::AnotherUnion::CORGE, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::get( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestLateUnion::AnotherUnion::Builder::setCorge( ::capnp::List< ::int32_t>::Reader value) { + _builder.setDataField( + 6 * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline void TestLateUnion::AnotherUnion::Builder::setCorge(std::initializer_list< ::int32_t> value) { + _builder.setDataField( + 6 * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::int32_t>::Builder TestLateUnion::AnotherUnion::Builder::initCorge(unsigned int size) { + _builder.setDataField( + 6 * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::CORGE); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::init( + _builder.getPointerField(2 * ::capnp::POINTERS), size); +} +inline void TestLateUnion::AnotherUnion::Builder::adoptCorge( + ::capnp::Orphan< ::capnp::List< ::int32_t>>&& value) { + _builder.setDataField( + 6 * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::CORGE); + ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::int32_t>> TestLateUnion::AnotherUnion::Builder::disownCorge() { + KJ_IREQUIRE(which() == TestLateUnion::AnotherUnion::CORGE, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnp::List< ::int32_t>>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestLateUnion::AnotherUnion::Reader::isGrault() const { + return which() == TestLateUnion::AnotherUnion::GRAULT; +} +inline bool TestLateUnion::AnotherUnion::Builder::isGrault() { + return which() == TestLateUnion::AnotherUnion::GRAULT; +} +inline bool TestLateUnion::AnotherUnion::Reader::hasGrault() const { + if (which() != TestLateUnion::AnotherUnion::GRAULT) return false; + return _reader.hasDataField(4 * ::capnp::ELEMENTS); +} + +inline bool TestLateUnion::AnotherUnion::Builder::hasGrault() { + if (which() != TestLateUnion::AnotherUnion::GRAULT) return false; + return _builder.hasDataField(4 * ::capnp::ELEMENTS); +} +inline float TestLateUnion::AnotherUnion::Reader::getGrault() const { + KJ_IREQUIRE(which() == TestLateUnion::AnotherUnion::GRAULT, + "Must check which() before get()ing a union member."); + return _reader.getDataField( + 4 * ::capnp::ELEMENTS); +} + +inline float TestLateUnion::AnotherUnion::Builder::getGrault() { + KJ_IREQUIRE(which() == TestLateUnion::AnotherUnion::GRAULT, + "Must check which() before get()ing a union member."); + return _builder.getDataField( + 4 * ::capnp::ELEMENTS); +} +inline void TestLateUnion::AnotherUnion::Builder::setGrault(float value) { + _builder.setDataField( + 6 * ::capnp::ELEMENTS, TestLateUnion::AnotherUnion::GRAULT); + _builder.setDataField( + 4 * ::capnp::ELEMENTS, value); +} + +inline bool TestOldVersion::Reader::hasOld1() const { + return _reader.hasDataField< ::int64_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestOldVersion::Builder::hasOld1() { + return _builder.hasDataField< ::int64_t>(0 * ::capnp::ELEMENTS); +} +inline ::int64_t TestOldVersion::Reader::getOld1() const { + return _reader.getDataField< ::int64_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestOldVersion::Builder::getOld1() { + return _builder.getDataField< ::int64_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestOldVersion::Builder::setOld1( ::int64_t value) { + _builder.setDataField< ::int64_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestOldVersion::Reader::hasOld2() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestOldVersion::Builder::hasOld2() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestOldVersion::Reader::getOld2() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestOldVersion::Builder::getOld2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestOldVersion::Builder::setOld2( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestOldVersion::Builder::initOld2(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestOldVersion::Builder::adoptOld2( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestOldVersion::Builder::disownOld2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestOldVersion::Reader::hasOld3() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestOldVersion::Builder::hasOld3() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestOldVersion::Reader TestOldVersion::Reader::getOld3() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestOldVersion::Builder TestOldVersion::Builder::getOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestOldVersion::Pipeline TestOldVersion::Pipeline::getOld3() const { + return ::capnproto_test::capnp::test::TestOldVersion::Pipeline(_typeless.getPointerField(1)); +} +inline void TestOldVersion::Builder::setOld3( ::capnproto_test::capnp::test::TestOldVersion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestOldVersion::Builder TestOldVersion::Builder::initOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::init( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestOldVersion::Builder::adoptOld3( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestOldVersion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestOldVersion> TestOldVersion::Builder::disownOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestOldVersion>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestNewVersion::Reader::hasOld1() const { + return _reader.hasDataField< ::int64_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestNewVersion::Builder::hasOld1() { + return _builder.hasDataField< ::int64_t>(0 * ::capnp::ELEMENTS); +} +inline ::int64_t TestNewVersion::Reader::getOld1() const { + return _reader.getDataField< ::int64_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::int64_t TestNewVersion::Builder::getOld1() { + return _builder.getDataField< ::int64_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestNewVersion::Builder::setOld1( ::int64_t value) { + _builder.setDataField< ::int64_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestNewVersion::Reader::hasOld2() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestNewVersion::Builder::hasOld2() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestNewVersion::Reader::getOld2() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestNewVersion::Builder::getOld2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestNewVersion::Builder::setOld2( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestNewVersion::Builder::initOld2(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestNewVersion::Builder::adoptOld2( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestNewVersion::Builder::disownOld2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestNewVersion::Reader::hasOld3() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestNewVersion::Builder::hasOld3() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestNewVersion::Reader TestNewVersion::Reader::getOld3() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestNewVersion::Builder TestNewVersion::Builder::getOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestNewVersion::Pipeline TestNewVersion::Pipeline::getOld3() const { + return ::capnproto_test::capnp::test::TestNewVersion::Pipeline(_typeless.getPointerField(1)); +} +inline void TestNewVersion::Builder::setOld3( ::capnproto_test::capnp::test::TestNewVersion::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestNewVersion::Builder TestNewVersion::Builder::initOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::init( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestNewVersion::Builder::adoptOld3( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestNewVersion>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestNewVersion> TestNewVersion::Builder::disownOld3() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestNewVersion>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestNewVersion::Reader::hasNew1() const { + return _reader.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} + +inline bool TestNewVersion::Builder::hasNew1() { + return _builder.hasDataField< ::int64_t>(1 * ::capnp::ELEMENTS); +} +inline ::int64_t TestNewVersion::Reader::getNew1() const { + return _reader.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, 987ll); +} + +inline ::int64_t TestNewVersion::Builder::getNew1() { + return _builder.getDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, 987ll); +} +inline void TestNewVersion::Builder::setNew1( ::int64_t value) { + _builder.setDataField< ::int64_t>( + 1 * ::capnp::ELEMENTS, value, 987ll); +} + +inline bool TestNewVersion::Reader::hasNew2() const { + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestNewVersion::Builder::hasNew2() { + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestNewVersion::Reader::getNew2() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(2 * ::capnp::POINTERS), + ::capnp::schemas::s_8ed75a7469f04ce3.encodedNode + 87, 3); +} +inline ::capnp::Text::Builder TestNewVersion::Builder::getNew2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(2 * ::capnp::POINTERS), + ::capnp::schemas::s_8ed75a7469f04ce3.encodedNode + 87, 3); +} +inline void TestNewVersion::Builder::setNew2( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestNewVersion::Builder::initNew2(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(2 * ::capnp::POINTERS), size); +} +inline void TestNewVersion::Builder::adoptNew2( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestNewVersion::Builder::disownNew2() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestStructUnion::Reader::hasUn() const { + return _reader.getDataField< ::uint16_t>(0 * ::capnp::ELEMENTS) != 0 + || !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestStructUnion::Builder::hasUn() { + return _builder.getDataField< ::uint16_t>(0 * ::capnp::ELEMENTS) != 0 + || !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline TestStructUnion::Un::Reader TestStructUnion::Reader::getUn() const { + return TestStructUnion::Un::Reader(_reader); +} +inline TestStructUnion::Un::Builder TestStructUnion::Builder::getUn() { + return TestStructUnion::Un::Builder(_builder); +} +inline TestStructUnion::Un::Pipeline TestStructUnion::Pipeline::getUn() const { + return TestStructUnion::Un::Pipeline(_typeless.noop()); +} +inline TestStructUnion::Un::Builder TestStructUnion::Builder::initUn() { + _builder.setDataField< ::uint16_t>(0 * ::capnp::ELEMENTS, 0); + _builder.getPointerField(0 * ::capnp::POINTERS).clear(); + return TestStructUnion::Un::Builder(_builder); +} +inline TestStructUnion::Un::Which TestStructUnion::Un::Reader::which() const { + return _reader.getDataField(0 * ::capnp::ELEMENTS); +} +inline TestStructUnion::Un::Which TestStructUnion::Un::Builder::which() { + return _builder.getDataField(0 * ::capnp::ELEMENTS); +} + +inline bool TestStructUnion::Un::Reader::isAllTypes() const { + return which() == TestStructUnion::Un::ALL_TYPES; +} +inline bool TestStructUnion::Un::Builder::isAllTypes() { + return which() == TestStructUnion::Un::ALL_TYPES; +} +inline bool TestStructUnion::Un::Reader::hasAllTypes() const { + if (which() != TestStructUnion::Un::ALL_TYPES) return false; + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestStructUnion::Un::Builder::hasAllTypes() { + if (which() != TestStructUnion::Un::ALL_TYPES) return false; + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Reader TestStructUnion::Un::Reader::getAllTypes() const { + KJ_IREQUIRE(which() == TestStructUnion::Un::ALL_TYPES, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestStructUnion::Un::Builder::getAllTypes() { + KJ_IREQUIRE(which() == TestStructUnion::Un::ALL_TYPES, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestStructUnion::Un::Builder::setAllTypes( ::capnproto_test::capnp::test::TestAllTypes::Reader value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestStructUnion::Un::ALL_TYPES); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestStructUnion::Un::Builder::initAllTypes() { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestStructUnion::Un::ALL_TYPES); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::init( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestStructUnion::Un::Builder::adoptAllTypes( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestStructUnion::Un::ALL_TYPES); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> TestStructUnion::Un::Builder::disownAllTypes() { + KJ_IREQUIRE(which() == TestStructUnion::Un::ALL_TYPES, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestStructUnion::Un::Reader::isObject() const { + return which() == TestStructUnion::Un::OBJECT; +} +inline bool TestStructUnion::Un::Builder::isObject() { + return which() == TestStructUnion::Un::OBJECT; +} +inline bool TestStructUnion::Un::Reader::hasObject() const { + if (which() != TestStructUnion::Un::OBJECT) return false; + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestStructUnion::Un::Builder::hasObject() { + if (which() != TestStructUnion::Un::OBJECT) return false; + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestObject::Reader TestStructUnion::Un::Reader::getObject() const { + KJ_IREQUIRE(which() == TestStructUnion::Un::OBJECT, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestObject>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestObject::Builder TestStructUnion::Un::Builder::getObject() { + KJ_IREQUIRE(which() == TestStructUnion::Un::OBJECT, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestObject>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestStructUnion::Un::Builder::setObject( ::capnproto_test::capnp::test::TestObject::Reader value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestStructUnion::Un::OBJECT); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestObject>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestObject::Builder TestStructUnion::Un::Builder::initObject() { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestStructUnion::Un::OBJECT); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestObject>::init( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestStructUnion::Un::Builder::adoptObject( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestObject>&& value) { + _builder.setDataField( + 0 * ::capnp::ELEMENTS, TestStructUnion::Un::OBJECT); + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestObject>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestObject> TestStructUnion::Un::Builder::disownObject() { + KJ_IREQUIRE(which() == TestStructUnion::Un::OBJECT, + "Must check which() before get()ing a union member."); + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestObject>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestInterface::FooParams::Reader::hasI() const { + return _reader.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestInterface::FooParams::Builder::hasI() { + return _builder.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestInterface::FooParams::Reader::getI() const { + return _reader.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestInterface::FooParams::Builder::getI() { + return _builder.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestInterface::FooParams::Builder::setI( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterface::FooParams::Reader::hasJ() const { + return _reader.hasDataField(32 * ::capnp::ELEMENTS); +} + +inline bool TestInterface::FooParams::Builder::hasJ() { + return _builder.hasDataField(32 * ::capnp::ELEMENTS); +} +inline bool TestInterface::FooParams::Reader::getJ() const { + return _reader.getDataField( + 32 * ::capnp::ELEMENTS); +} + +inline bool TestInterface::FooParams::Builder::getJ() { + return _builder.getDataField( + 32 * ::capnp::ELEMENTS); +} +inline void TestInterface::FooParams::Builder::setJ(bool value) { + _builder.setDataField( + 32 * ::capnp::ELEMENTS, value); +} + +inline bool TestInterface::FooResults::Reader::hasX() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterface::FooResults::Builder::hasX() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestInterface::FooResults::Reader::getX() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestInterface::FooResults::Builder::getX() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestInterface::FooResults::Builder::setX( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestInterface::FooResults::Builder::initX(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestInterface::FooResults::Builder::adoptX( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestInterface::FooResults::Builder::disownX() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestInterface::BazParams::Reader::hasS() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestInterface::BazParams::Builder::hasS() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Reader TestInterface::BazParams::Reader::getS() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestInterface::BazParams::Builder::getS() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Pipeline TestInterface::BazParams::Pipeline::getS() const { + return ::capnproto_test::capnp::test::TestAllTypes::Pipeline(_typeless.getPointerField(0)); +} +inline void TestInterface::BazParams::Builder::setS( ::capnproto_test::capnp::test::TestAllTypes::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestAllTypes::Builder TestInterface::BazParams::Builder::initS() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::init( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestInterface::BazParams::Builder::adoptS( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestAllTypes> TestInterface::BazParams::Builder::disownS() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestAllTypes>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestPipeline::Box::Reader::hasCap() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::Box::Builder::hasCap() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::Box::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::Box::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::Box::Pipeline::getCap() const { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestPipeline::Box::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestPipeline::Box::Builder::setCap(const ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), cap); +} +inline void TestPipeline::Box::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestPipeline::Box::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestPipeline::GetCapParams::Reader::hasN() const { + return _reader.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} + +inline bool TestPipeline::GetCapParams::Builder::hasN() { + return _builder.hasDataField< ::uint32_t>(0 * ::capnp::ELEMENTS); +} +inline ::uint32_t TestPipeline::GetCapParams::Reader::getN() const { + return _reader.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} + +inline ::uint32_t TestPipeline::GetCapParams::Builder::getN() { + return _builder.getDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS); +} +inline void TestPipeline::GetCapParams::Builder::setN( ::uint32_t value) { + _builder.setDataField< ::uint32_t>( + 0 * ::capnp::ELEMENTS, value); +} + +inline bool TestPipeline::GetCapParams::Reader::hasInCap() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetCapParams::Builder::hasInCap() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::GetCapParams::Reader::getInCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::GetCapParams::Builder::getInCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::GetCapParams::Pipeline::getInCap() const { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestPipeline::GetCapParams::Builder::setInCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestPipeline::GetCapParams::Builder::setInCap(const ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), cap); +} +inline void TestPipeline::GetCapParams::Builder::adoptInCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestPipeline::GetCapParams::Builder::disownInCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestPipeline::GetCapResults::Reader::hasS() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetCapResults::Builder::hasS() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestPipeline::GetCapResults::Reader::getS() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestPipeline::GetCapResults::Builder::getS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestPipeline::GetCapResults::Builder::setS( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestPipeline::GetCapResults::Builder::initS(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestPipeline::GetCapResults::Builder::adoptS( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestPipeline::GetCapResults::Builder::disownS() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestPipeline::GetCapResults::Reader::hasOutBox() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::GetCapResults::Builder::hasOutBox() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestPipeline::Box::Reader TestPipeline::GetCapResults::Reader::getOutBox() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::get( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestPipeline::Box::Builder TestPipeline::GetCapResults::Builder::getOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::get( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestPipeline::Box::Pipeline TestPipeline::GetCapResults::Pipeline::getOutBox() const { + return ::capnproto_test::capnp::test::TestPipeline::Box::Pipeline(_typeless.getPointerField(1)); +} +inline void TestPipeline::GetCapResults::Builder::setOutBox( ::capnproto_test::capnp::test::TestPipeline::Box::Reader value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::set( + _builder.getPointerField(1 * ::capnp::POINTERS), value); +} +inline ::capnproto_test::capnp::test::TestPipeline::Box::Builder TestPipeline::GetCapResults::Builder::initOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::init( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline void TestPipeline::GetCapResults::Builder::adoptOutBox( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::Box>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::adopt( + _builder.getPointerField(1 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestPipeline::Box> TestPipeline::GetCapResults::Builder::disownOutBox() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestPipeline::Box>::disown( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} + +inline bool TestPipeline::TestPointersParams::Reader::hasCap() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::TestPointersParams::Builder::hasCap() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::TestPointersParams::Reader::getCap() const { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::TestPointersParams::Builder::getCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnproto_test::capnp::test::TestInterface::Client TestPipeline::TestPointersParams::Pipeline::getCap() const { + return ::capnproto_test::capnp::test::TestInterface::Client(_typeless.getPointerField(0).asCap()); +} +inline void TestPipeline::TestPointersParams::Builder::setCap( ::capnproto_test::capnp::test::TestInterface::Client&& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(cap)); +} +inline void TestPipeline::TestPointersParams::Builder::setCap(const ::capnproto_test::capnp::test::TestInterface::Client& cap) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), cap); +} +inline void TestPipeline::TestPointersParams::Builder::adoptCap( + ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface>&& value) { + ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnproto_test::capnp::test::TestInterface> TestPipeline::TestPointersParams::Builder::disownCap() { + return ::capnp::_::PointerHelpers< ::capnproto_test::capnp::test::TestInterface>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestPipeline::TestPointersParams::Reader::hasObj() const { + return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::TestPointersParams::Builder::hasObj() { + return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::ObjectPointer::Reader TestPipeline::TestPointersParams::Reader::getObj() const { + return ::capnp::ObjectPointer::Reader( + _reader.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::ObjectPointer::Builder TestPipeline::TestPointersParams::Builder::getObj() { + return ::capnp::ObjectPointer::Builder( + _builder.getPointerField(1 * ::capnp::POINTERS)); +} +inline ::capnp::ObjectPointer::Builder TestPipeline::TestPointersParams::Builder::initObj() { + auto result = ::capnp::ObjectPointer::Builder( + _builder.getPointerField(1 * ::capnp::POINTERS)); + result.clear(); + return result; +} + +inline bool TestPipeline::TestPointersParams::Reader::hasList() const { + return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline bool TestPipeline::TestPointersParams::Builder::hasList() { + return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface>::Reader TestPipeline::TestPointersParams::Reader::getList() const { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>::get( + _reader.getPointerField(2 * ::capnp::POINTERS)); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface>::Builder TestPipeline::TestPointersParams::Builder::getList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>::get( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} +inline void TestPipeline::TestPointersParams::Builder::setList( ::capnp::List< ::capnproto_test::capnp::test::TestInterface>::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline void TestPipeline::TestPointersParams::Builder::setList(std::initializer_list< ::capnproto_test::capnp::test::TestInterface::Client> value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>::set( + _builder.getPointerField(2 * ::capnp::POINTERS), value); +} +inline ::capnp::List< ::capnproto_test::capnp::test::TestInterface>::Builder TestPipeline::TestPointersParams::Builder::initList(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>::init( + _builder.getPointerField(2 * ::capnp::POINTERS), size); +} +inline void TestPipeline::TestPointersParams::Builder::adoptList( + ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>&& value) { + ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>::adopt( + _builder.getPointerField(2 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>> TestPipeline::TestPointersParams::Builder::disownList() { + return ::capnp::_::PointerHelpers< ::capnp::List< ::capnproto_test::capnp::test::TestInterface>>::disown( + _builder.getPointerField(2 * ::capnp::POINTERS)); +} + +inline bool TestSturdyRefHostId::Reader::hasHost() const { + return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline bool TestSturdyRefHostId::Builder::hasHost() { + return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull(); +} +inline ::capnp::Text::Reader TestSturdyRefHostId::Reader::getHost() const { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _reader.getPointerField(0 * ::capnp::POINTERS)); +} +inline ::capnp::Text::Builder TestSturdyRefHostId::Builder::getHost() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::get( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} +inline void TestSturdyRefHostId::Builder::setHost( ::capnp::Text::Reader value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::set( + _builder.getPointerField(0 * ::capnp::POINTERS), value); +} +inline ::capnp::Text::Builder TestSturdyRefHostId::Builder::initHost(unsigned int size) { + return ::capnp::_::PointerHelpers< ::capnp::Text>::init( + _builder.getPointerField(0 * ::capnp::POINTERS), size); +} +inline void TestSturdyRefHostId::Builder::adoptHost( + ::capnp::Orphan< ::capnp::Text>&& value) { + ::capnp::_::PointerHelpers< ::capnp::Text>::adopt( + _builder.getPointerField(0 * ::capnp::POINTERS), kj::mv(value)); +} +inline ::capnp::Orphan< ::capnp::Text> TestSturdyRefHostId::Builder::disownHost() { + return ::capnp::_::PointerHelpers< ::capnp::Text>::disown( + _builder.getPointerField(0 * ::capnp::POINTERS)); +} + +inline bool TestSturdyRefObjectId::Reader::hasTag() const { + return _reader.hasDataField< ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag>(0 * ::capnp::ELEMENTS); +} + +inline bool TestSturdyRefObjectId::Builder::hasTag() { + return _builder.hasDataField< ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag>(0 * ::capnp::ELEMENTS); +} +inline ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag TestSturdyRefObjectId::Reader::getTag() const { + return _reader.getDataField< ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag>( + 0 * ::capnp::ELEMENTS); +} + +inline ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag TestSturdyRefObjectId::Builder::getTag() { + return _builder.getDataField< ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag>( + 0 * ::capnp::ELEMENTS); +} +inline void TestSturdyRefObjectId::Builder::setTag( ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag value) { + _builder.setDataField< ::capnproto_test::capnp::test::TestSturdyRefObjectId::Tag>( + 0 * ::capnp::ELEMENTS, value); +} + +} // namespace +} // namespace +} // namespace + +#endif // CAPNP_INCLUDED_d508eebdc2dc42b8_ From 5251cb55756332887b042f3d55f26a21a553520f Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Tue, 12 Nov 2013 20:28:23 -0800 Subject: [PATCH 32/43] Add upcast/cast_as to DynamicCapability. Also changed EventLoop. wait_remote -> wait --- capnp/capnp.pyx | 24 +++++++++++++++++++++++- capnp/capnp_cpp.pxd | 1 + examples/example_capability.py | 2 +- examples/example_client.py | 2 +- test/test_capability.capnp | 8 +++----- test/test_capability.py | 30 ++++++++++++++++++++---------- test/test_rpc.py | 2 +- 7 files changed, 50 insertions(+), 19 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 8391a3f..9a3f89a 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -1163,7 +1163,7 @@ cdef class EventLoop: Py_INCREF(func) return Promise()._init(capnp.evalLater(self.thisptr, func)) - cpdef wait_remote(self, _RemotePromise promise) except +: + cpdef wait(self, _RemotePromise promise) except +: if promise.is_consumed: raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') @@ -1263,6 +1263,28 @@ cdef class _DynamicCapabilityClient: return _partial(self._request, short_name) return _partial(self._send, name) + cpdef upcast(self, schema) except+: + cdef _InterfaceSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + + return _DynamicCapabilityClient()._init(self.thisptr.upcast(s.thisptr), self._parent) + + cpdef cast_as(self, schema) except+: + cdef _InterfaceSchema s + if hasattr(schema, 'schema'): + s = schema.schema + else: + s = schema + return _DynamicCapabilityClient()._init(self.thisptr.castAs(s.thisptr), self._parent) + + property schema: + """A property that returns the _InterfaceSchema object matching this client""" + def __get__(self): + return _InterfaceSchema()._init(self.thisptr.getSchema()) + cdef class _CapabilityClient: cdef C_Capability.Client * thisptr cdef public object _parent diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index c799849..eabefc9 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -157,6 +157,7 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": Client() Client(Client&) Client upcast(InterfaceSchema requestedSchema) + DynamicCapability.Client castAs"castAs< ::capnp::DynamicCapability>"(InterfaceSchema) InterfaceSchema getSchema() Request newRequest(char * methodName, uint firstSegmentWordSize) diff --git a/examples/example_capability.py b/examples/example_capability.py index ba356e8..78006d4 100644 --- a/examples/example_capability.py +++ b/examples/example_capability.py @@ -30,7 +30,7 @@ def example_simple_rpc(): cap = cap.cast_as(capability.TestInterface) remote = cap.foo(i=5) - response = loop.wait_remote(remote) + response = loop.wait(remote) assert response.x == '125' diff --git a/examples/example_client.py b/examples/example_client.py index 075d6d0..90c65c3 100644 --- a/examples/example_client.py +++ b/examples/example_client.py @@ -18,7 +18,7 @@ def example_client(): cap = cap.cast_as(test_capnp.TestInterface) remote = cap.foo(i=5) - response = loop.wait_remote(remote) + response = loop.wait(remote) assert response.x == 'foo' diff --git a/test/test_capability.capnp b/test/test_capability.capnp index 8ce0030..9939e5f 100644 --- a/test/test_capability.capnp +++ b/test/test_capability.capnp @@ -29,11 +29,9 @@ interface TestInterface { # baz @2 (s: TestAllTypes); } -# interface TestExtends extends(TestInterface) { -# qux @0 (); -# corge @1 TestAllTypes -> (); -# grault @2 () -> TestAllTypes; -# } +interface TestExtends extends(TestInterface) { + qux @0 (); +} interface TestPipeline { getCap @0 (n: UInt32, inCap :TestInterface) -> (s: Text, outBox :Box); diff --git a/test/test_capability.py b/test/test_capability.py index 857e319..230abaa 100644 --- a/test/test_capability.py +++ b/test/test_capability.py @@ -32,7 +32,7 @@ def test_client(capability): req.i = 5 remote = req.send() - response = loop.wait_remote(remote) + response = loop.wait(remote) assert response.x == '26' @@ -40,7 +40,7 @@ def test_client(capability): req.i = 5 remote = req.send() - response = loop.wait_remote(remote) + response = loop.wait(remote) assert response.x == '26' @@ -63,13 +63,13 @@ def test_simple_client(capability): client = capability.TestInterface.new_client(Server(), loop) remote = client._send('foo', i=5) - response = loop.wait_remote(remote) + response = loop.wait(remote) assert response.x == '26' remote = client.foo(i=5) - response = loop.wait_remote(remote) + response = loop.wait(remote) assert response.x == '26' @@ -93,10 +93,10 @@ def test_pipeline(capability): outCap = remote.outBox.cap pipelinePromise = outCap.foo(i=10) - response = loop.wait_remote(pipelinePromise) + response = loop.wait(pipelinePromise) assert response.x == '150' - response = loop.wait_remote(remote) + response = loop.wait(remote) assert response.s == '26_foo' class BadServer: @@ -114,7 +114,7 @@ def test_exception_client(capability): remote = client._send('foo', i=5) with pytest.raises(ValueError): - loop.wait_remote(remote) + loop.wait(remote) class BadPipelineServer: def getCap(self, context): @@ -135,7 +135,7 @@ def test_exception_chain(capability): remote = client.getCap(n=5, inCap=foo_client) try: - loop.wait_remote(remote) + loop.wait(remote) except Exception as e: assert str(e) == 'test' @@ -151,7 +151,17 @@ def test_pipeline_exception(capability): pipelinePromise = outCap.foo(i=10) with pytest.raises(Exception): - loop.wait_remote(pipelinePromise) + loop.wait(pipelinePromise) with pytest.raises(Exception): - loop.wait_remote(remote) + loop.wait(remote) + +def test_casting(capability): + loop = capnp.EventLoop() + + client = capability.TestExtends.new_client(Server(), loop) + client2 = client.upcast(capability.TestInterface) + client3 = client2.cast_as(capability.TestInterface) + + with pytest.raises(Exception): + client.upcast(capability.TestPipeline) diff --git a/test/test_rpc.py b/test/test_rpc.py index ec29984..bd0468a 100644 --- a/test/test_rpc.py +++ b/test/test_rpc.py @@ -35,6 +35,6 @@ def test_simple_rpc(capability): cap = cap.cast_as(capability.TestInterface) remote = cap.foo(i=5) - response = loop.wait_remote(remote) + response = loop.wait(remote) assert response.x == '125' From 11543b7abfb898e84c9412a7b5563e4481ffcf9b Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 10:58:16 -0800 Subject: [PATCH 33/43] Add ability to pass Restorer to RpcClient. Also various fixups and added __dir__ reflection to DynamicCapabilityClient --- capnp/capnp.pyx | 64 ++++++++++++++++++++++++++++------ capnp/capnp_cpp.pxd | 19 ++++++++-- capnp/rpcHelper.h | 10 ++++++ examples/example_capability.py | 2 +- test/test_rpc.py | 2 +- 5 files changed, 82 insertions(+), 15 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 9a3f89a..19af3fa 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side, AsyncIoStream_wrapFd, AsyncIoStream, Own +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, makeRpcClientWithRestorer, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side, AsyncIoStream_wrapFd, AsyncIoStream, Own from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -616,10 +616,13 @@ cdef class _DynamicStructReader: """ cdef C_DynamicStruct.Reader thisptr cdef public object _parent + cdef public bint is_root cdef object _obj_to_pin - cdef _init(self, C_DynamicStruct.Reader other, object parent): + + cdef _init(self, C_DynamicStruct.Reader other, object parent, bint isRoot=False): self.thisptr = other self._parent = parent + self.is_root = isRoot return self def __getattr__(self, field): @@ -695,16 +698,17 @@ cdef class _DynamicStructBuilder: """ cdef C_DynamicStruct.Builder thisptr cdef public object _parent - cdef bint _is_root, _is_written + cdef public bint is_root + cdef bint _is_written cdef _init(self, C_DynamicStruct.Builder other, object parent, bint isRoot = False): self.thisptr = other self._parent = parent - self._is_root = isRoot + self.is_root = isRoot self._is_written = False return self cdef _check_write(self): - if not self._is_root: + if not self.is_root: raise ValueError("You can only call write() on the message's root struct.") if self._is_written: _warnings.warn("This message has already been written once. Be very careful that you're not setting Text/Struct/List fields more than once, since that will cause memory leaks (both in memory and in the serialized data). You can disable this warning by setting the `_is_written` field of this object to False after every write.") @@ -871,7 +875,7 @@ cdef class _DynamicStructBuilder: """ cdef _DynamicStructReader reader reader = _DynamicStructReader()._init(self.thisptr.asReader(), - self._parent) + self._parent, self.is_root) reader._obj_to_pin = self return reader @@ -1285,6 +1289,9 @@ cdef class _DynamicCapabilityClient: def __get__(self): return _InterfaceSchema()._init(self.thisptr.getSchema()) + def __dir__(self): + return list(self.schema.method_names) + cdef class _CapabilityClient: cdef C_Capability.Client * thisptr cdef public object _parent @@ -1338,12 +1345,16 @@ cdef class _TwoPartyVatNetwork: cdef class RpcClient: cdef RpcSystem * thisptr cdef public _TwoPartyVatNetwork network - cdef public object loop + cdef public object loop, restorer - def __init__(self, EventLoop loop, FdAsyncIoStream stream): + def __init__(self, EventLoop loop, FdAsyncIoStream stream, Restorer restorer=None): self.loop = loop self.network = _TwoPartyVatNetwork()._init(loop, deref(stream.thisptr), capnp.CLIENT) - self.thisptr = new RpcSystem(makeRpcClient(deref(self.network.thisptr), loop.thisptr)) + if restorer is None: + self.thisptr = new RpcSystem(makeRpcClient(deref(self.network.thisptr), loop.thisptr)) + else: + self.restorer = restorer + self.thisptr = new RpcSystem(makeRpcClientWithRestorer(deref(self.network.thisptr), loop.thisptr, deref(restorer.thisptr))) def __dealloc__(self): del self.thisptr @@ -1351,19 +1362,30 @@ cdef class RpcClient: cpdef restore(self, objectId) except+: cdef _MessageBuilder builder cdef _MessageReader reader + + if not hasattr(objectId, 'is_root'): + raise ValueError("objectId was not a valid Cap'n Proto struct") + if not objectId.is_root: + raise ValueError("objectId must be the root of a Cap'n Proto message, ie. addressbook_capnp.Person.new_message()") + try: builder = objectId._parent - return _CapabilityClient()._init(restoreHelper(deref(self.thisptr), deref(builder.thisptr)), self) except: reader = objectId._parent + + if builder is not None: + return _CapabilityClient()._init(restoreHelper(deref(self.thisptr), deref(builder.thisptr)), self) + elif reader is not None: return _CapabilityClient()._init(restoreHelper(deref(self.thisptr), deref(reader.thisptr)), self) + else: + raise ValueError("objectId unexpectedly was not convertible to the proper type") cdef class RpcServer: cdef RpcSystem * thisptr cdef public _TwoPartyVatNetwork network cdef public object loop, restorer - def __init__(self, EventLoop loop, Restorer restorer, FdAsyncIoStream stream): + def __init__(self, EventLoop loop, FdAsyncIoStream stream, Restorer restorer): self.loop = loop self.restorer = restorer self.network = _TwoPartyVatNetwork()._init(loop, deref(stream.thisptr), capnp.SERVER) @@ -1460,11 +1482,31 @@ cdef class _StructSchema: cdef class _InterfaceSchema: cdef C_InterfaceSchema thisptr + cdef object __method_names cdef _init(self, C_InterfaceSchema other): self.thisptr = other return self + property method_names: + """A tuple of the function names in the interface.""" + def __get__(self): + if self.__method_names is not None: + return self.__method_names + fieldlist = self.thisptr.getMethods() + nfields = fieldlist.size() + self.__method_names = tuple(fieldlist[i].getProto().getName().cStr() + for i in xrange(nfields)) + return self.__method_names + + property node: + """The raw schema node""" + def __get__(self): + return _DynamicStructReader()._init(self.thisptr.getProto(), None) + + def __repr__(self): + return '' % self.node.displayName + cdef class _ParsedSchema(_Schema): cdef C_ParsedSchema thisptr_child cdef _init_child(self, C_ParsedSchema other): diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index eabefc9..ff7e736 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -1,7 +1,7 @@ # schema.capnp.cpp.pyx # distutils: language = c++ # distutils: extra_compile_args = --std=c++11 -from schema_cpp cimport Node, Data, StructNode, EnumNode, MessageBuilder, MessageReader +from schema_cpp cimport Node, Data, StructNode, EnumNode, InterfaceNode, MessageBuilder, MessageReader from async_cpp cimport PyPromise, VoidPromise, Promise from cpython.ref cimport PyObject @@ -61,7 +61,21 @@ cdef extern from "capnp/schema.h" namespace " ::capnp": InterfaceSchema asInterface() except + cdef cppclass InterfaceSchema(Schema): - pass + cppclass Method: + InterfaceNode.Method.Reader getProto() + InterfaceSchema getContainingInterface() + uint16_t getOrdinal() + uint getIndex() + + cppclass MethodList: + uint size() + Method operator[](uint index) + + MethodList getMethods() + Maybe[Method] findMethodByName(StringPtr name) + Method getMethodByName(StringPtr name) + bint extends(InterfaceSchema other) + # kj::Maybe findSuperclass(uint64_t typeId) const; cdef cppclass StructSchema(Schema): cppclass Field: @@ -226,6 +240,7 @@ cdef extern from "rpcHelper.h": PyRestorer(PyObject *, StructSchema&) Capability.Client restoreHelper(RpcSystem&, MessageBuilder&) Capability.Client restoreHelper(RpcSystem&, MessageReader&) + RpcSystem makeRpcClientWithRestorer(TwoPartyVatNetwork&, EventLoop&, PyRestorer&) cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef cppclass DynamicEnum: diff --git a/capnp/rpcHelper.h b/capnp/rpcHelper.h index 56e5aa1..8ec6daf 100644 --- a/capnp/rpcHelper.h +++ b/capnp/rpcHelper.h @@ -47,3 +47,13 @@ capnp::Capability::Client restoreHelper(capnp::RpcSystem()); } + +template +capnp::RpcSystem makeRpcClientWithRestorer( + capnp::VatNetwork& network, + const kj::EventLoop& eventLoop, PyRestorer& restorer) { + using namespace capnp; + return RpcSystem(network, + kj::Maybe&>(restorer), eventLoop); +} diff --git a/examples/example_capability.py b/examples/example_capability.py index 78006d4..7626c36 100644 --- a/examples/example_capability.py +++ b/examples/example_capability.py @@ -22,7 +22,7 @@ def example_simple_rpc(): write_stream = capnp.FdAsyncIoStream(write.fileno()) restorer = capnp.Restorer(capability.TestSturdyRefObjectId, _restore) - server = capnp.RpcServer(loop, restorer, write_stream) + server = capnp.RpcServer(loop, write_stream, restorer) client = capnp.RpcClient(loop, read_stream) ref = capability.TestSturdyRefObjectId.new_message() diff --git a/test/test_rpc.py b/test/test_rpc.py index bd0468a..c065cf3 100644 --- a/test/test_rpc.py +++ b/test/test_rpc.py @@ -27,7 +27,7 @@ def test_simple_rpc(capability): write_stream = capnp.FdAsyncIoStream(write.fileno()) restorer = capnp.Restorer(capability.TestSturdyRefObjectId, _restore) - server = capnp.RpcServer(loop, restorer, write_stream) + server = capnp.RpcServer(loop, write_stream, restorer) client = capnp.RpcClient(loop, read_stream) ref = capability.TestSturdyRefObjectId.new_message() From 238f8b2c2f0b2aee853b458d5ff5b77d01c22929 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 12:02:43 -0800 Subject: [PATCH 34/43] Add get_dependency to all Schema classes --- capnp/capnp.pyx | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 19af3fa..d1e2ba8 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -1469,6 +1469,9 @@ cdef class _StructSchema: def __get__(self): return _DynamicStructReader()._init(self.thisptr.getProto(), None) + cpdef get_dependency(self, id): + return _Schema()._init(self.thisptr.getDependency(id)) + def __richcmp__(_StructSchema self, _StructSchema other, mode): if mode == 2: return self.thisptr == other.thisptr @@ -1504,6 +1507,9 @@ cdef class _InterfaceSchema: def __get__(self): return _DynamicStructReader()._init(self.thisptr.getProto(), None) + cpdef get_dependency(self, id): + return _Schema()._init(self.thisptr.getDependency(id)) + def __repr__(self): return '' % self.node.displayName From 0f68366905425f04018c8f70f5cd16f4faef8d6b Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 12:21:48 -0800 Subject: [PATCH 35/43] Stop using pointer to TwoPartyVatNetwork and replace with Own reference --- capnp/capnp.pyx | 9 +++------ capnp/capnp_cpp.pxd | 1 + 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index d1e2ba8..17304c3 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, makeRpcClientWithRestorer, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side, AsyncIoStream_wrapFd, AsyncIoStream, Own +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, makeRpcClientWithRestorer, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side, AsyncIoStream_wrapFd, AsyncIoStream, Own, makeTwoPartyVatNetwork from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -1333,15 +1333,12 @@ cdef class Restorer: del self.thisptr cdef class _TwoPartyVatNetwork: - cdef C_TwoPartyVatNetwork * thisptr + cdef Own[C_TwoPartyVatNetwork] thisptr cdef _init(self, EventLoop loop, AsyncIoStream & stream, Side side): - self.thisptr = new C_TwoPartyVatNetwork(loop.thisptr, stream, side) + self.thisptr = makeTwoPartyVatNetwork(loop.thisptr, stream, side) return self - def __dealloc__(self): - del self.thisptr - cdef class RpcClient: cdef RpcSystem * thisptr cdef public _TwoPartyVatNetwork network diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index ff7e736..3d06528 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -26,6 +26,7 @@ cdef extern from "kj/string.h" namespace " ::kj": cdef extern from "kj/memory.h" namespace " ::kj": cdef cppclass Own[T]: T& operator*() + Own[TwoPartyVatNetwork] makeTwoPartyVatNetwork" ::kj::heap< ::capnp::TwoPartyVatNetwork>"(EventLoop &, AsyncIoStream& stream, Side) cdef extern from "kj/string-tree.h" namespace " ::kj": cdef cppclass StringTree: From 7ac8c25c1ab814590fe4f4ec9957f46d6f67daee Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 16:14:41 -0800 Subject: [PATCH 36/43] Add make check back to travis --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index b7ee71d..663186a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -18,7 +18,7 @@ before_install: --slave /usr/bin/g++ g++ /usr/bin/g++-4.8 --slave /usr/bin/gcov gcov /usr/bin/gcov-4.8 - sudo update-alternatives --quiet --set gcc /usr/bin/gcc-4.8 - - wget https://github.com/kentonv/capnproto/archive/master.zip && unzip master.zip && cd capnproto-master/c++ && ./setup-autotools.sh && autoreconf -i && ./configure && make -j6 && sudo make install && sudo ldconfig && cd ../.. + - wget https://github.com/kentonv/capnproto/archive/master.zip && unzip master.zip && cd capnproto-master/c++ && ./setup-autotools.sh && autoreconf -i && ./configure && make -j6 check && sudo make install && sudo ldconfig && cd ../.. - pip install -U setuptools - pip install cython - pip install pytest From 72c36c39974bc0c862a75ec55774f86551683260 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 17:53:34 -0800 Subject: [PATCH 37/43] Change exception handling code. Now we are directly wrapping kj::Exception and mapping it's 'Nature' enum to Python Error types, and if none match, return a wrapped KjException --- capnp/capabilityHelper.h | 21 ++++ capnp/capnp.pyx | 223 +++++++++++++++++++++++++++++++-------- capnp/capnp_cpp.pxd | 86 +++++++++------ capnp/schema_cpp.pxd | 19 ++-- 4 files changed, 265 insertions(+), 84 deletions(-) diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index 993e031..8a314ab 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -10,8 +10,29 @@ extern "C" { PyObject * wrap_dynamic_struct_reader(capnp::DynamicStruct::Reader &); ::kj::Promise * call_server_method(PyObject * py_server, char * name, capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> & context); PyObject * wrap_kj_exception(kj::Exception &); + PyObject * wrap_kj_exception_for_reraise(kj::Exception &); } +void reraise_kj_exception() { + try { + if (PyErr_Occurred()) + ; // let the latest Python exn pass through and ignore the current one + else + throw; + } + catch (kj::Exception& exn) { + auto obj = wrap_kj_exception_for_reraise(exn); + PyErr_SetObject((PyObject*)obj->ob_type, obj); + } + catch (const std::exception& exn) { + PyErr_SetString(PyExc_RuntimeError, exn.what()); + } + catch (...) + { + PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); + } +} + void check_py_error() { PyObject * err = PyErr_Occurred(); if(err) { diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 17304c3..ca2ca18 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -9,7 +9,7 @@ cimport cython cimport capnp_cpp as capnp cimport schema_cpp -from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, makeRpcClientWithRestorer, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side, AsyncIoStream_wrapFd, AsyncIoStream, Own, makeTwoPartyVatNetwork +from capnp_cpp cimport Schema as C_Schema, StructSchema as C_StructSchema, InterfaceSchema as C_InterfaceSchema, DynamicStruct as C_DynamicStruct, DynamicValue as C_DynamicValue, Type as C_Type, DynamicList as C_DynamicList, fixMaybe, getEnumString, SchemaParser as C_SchemaParser, ParsedSchema as C_ParsedSchema, VOID, ArrayPtr, StringPtr, String, StringTree, DynamicOrphan as C_DynamicOrphan, ObjectPointer as C_DynamicObject, DynamicCapability as C_DynamicCapability, new_client, new_server, server_to_client, Request, Response, RemotePromise, convert_to_pypromise, UnixEventLoop, PyPromise, VoidPromise, CallContext, PyRestorer, RpcSystem, makeRpcServer, makeRpcClient, makeRpcClientWithRestorer, restoreHelper, Capability as C_Capability, TwoPartyVatNetwork as C_TwoPartyVatNetwork, Side, AsyncIoStream_wrapFd, AsyncIoStream, Own, makeTwoPartyVatNetwork, PromiseFulfillerPair as C_PromiseFulfillerPair, copyPromiseFulfillerPair, newPromiseAndFulfiller, reraise_kj_exception from schema_cpp cimport Node as C_Node, EnumNode as C_EnumNode from cython.operator cimport dereference as deref @@ -82,8 +82,127 @@ cdef public C_Capability.Client * call_py_restorer(PyObject * _restorer, C_Dynam return new C_Capability.Client(server_to_client(server.schema.thisptr, server.server)) +cdef extern from "" namespace " ::kj": + String strStructReader" ::kj::str"(C_DynamicStruct.Reader) + String strStructBuilder" ::kj::str"(C_DynamicStruct.Builder) + String strRequest" ::kj::str"(Request &) + String strListReader" ::kj::str"(C_DynamicList.Reader) + String strListBuilder" ::kj::str"(C_DynamicList.Builder) + String strException" ::kj::str"(capnp.Exception) + +def _make_enum(enum_name, *sequential, **named): + enums = dict(zip(sequential, range(len(sequential))), **named) + reverse = dict((value, key) for key, value in enums.iteritems()) + enums['reverse_mapping'] = reverse + return type(enum_name, (), enums) + +_Nature = _make_enum('Nature', + PRECONDITION = 0, + LOCAL_BUG = 1, + OS_ERROR = 2, + NETWORK_FAILURE = 3, + OTHER = 4) +_Durability = _make_enum('Durability', + PERMANENT = 0, + TEMPORARY = 1, + OVERLOADED = 2) + +cdef class _KjExceptionWrapper: + cdef capnp.Exception * thisptr + + cdef _init(self, capnp.Exception & other): + self.thisptr = new capnp.Exception(moveException(other)) + return self + + def __dealloc__(self): + del self.thisptr + + property file: + def __get__(self): + return self.thisptr.getFile() + property line: + def __get__(self): + return self.thisptr.getLine() + property nature: + def __get__(self): + cdef int temp = self.thisptr.getNature() + return _Nature.reverse_mapping[temp] + property durability: + def __get__(self): + cdef int temp = self.thisptr.getDurability() + return _Durability.reverse_mapping[temp] + property description: + def __get__(self): + return self.thisptr.getDescription().cStr() + + def __str__(self): + return strException(deref(self.thisptr)).cStr() + +# Extension classes can't inherit from Exception, so we're going to proxy wrap kj::Exception, and forward all calls to it from this Python class +class KjException(Exception): + Nature = _Nature + Durability = _Durability + + def __init__(self, message=None, nature=None, durability=None, wrapper=None): + if wrapper is not None: + self.wrapper = wrapper + self.message = str(wrapper) + else: + self.message = message + self.nature = nature + self.durability = durability + + @property + def file(self): + return self.wrapper.file + @property + def line(self): + return self.wrapper.line + @property + def nature(self): + if self.wrapper is not None: + return self.wrapper.nature + else: + return self.nature + @property + def durability(self): + if self.wrapper is not None: + return self.wrapper.durability + else: + return self.durability + @property + def description(self): + if self.wrapper is not None: + return self.wrapper.description + else: + return self.message + + def __str__(self): + return self.message + cdef public object wrap_kj_exception(capnp.Exception & exception): - return None # TODO + wrapper = _KjExceptionWrapper()._init(exception) + ret = KjException(wrapper=wrapper) + + return ret + +cdef public object wrap_kj_exception_for_reraise(capnp.Exception & exception): + wrapper = _KjExceptionWrapper()._init(exception) + + nature = wrapper.nature + + if wrapper.nature == 'PRECONDITION': + return ValueError(str(wrapper)) + # elif wrapper.nature == 'LOCAL_BUG': + # return ValueError(str(wrapper)) + if wrapper.nature == 'OS_ERROR': + return OSError(str(wrapper)) + if wrapper.nature == 'NETWORK_FAILURE': + return IOError(str(wrapper)) + + + ret = KjException(wrapper=wrapper) + return ret ctypedef fused _DynamicStructReaderOrBuilder: _DynamicStructReader @@ -94,16 +213,16 @@ ctypedef fused _DynamicSetterClasses: C_DynamicStruct.Builder Request +ctypedef fused _PromiseTypes: + Promise + _RemotePromise + _VoidPromise + PromiseFulfillerPair + cdef extern from "Python.h": cdef int PyObject_AsReadBuffer(object, void** b, Py_ssize_t* c) -def _make_enum(enum_name, *sequential, **named): - enums = dict(zip(sequential, range(len(sequential))), **named) - reverse = dict((value, key) for key, value in enums.iteritems()) - enums['reverse_mapping'] = reverse - return type(enum_name, (), enums) - -_Type = _make_enum('DynamicValue.Type', +Type = _make_enum('DynamicValue.Type', UNKNOWN = capnp.TYPE_UNKNOWN, VOID = capnp.TYPE_VOID, BOOL = capnp.TYPE_BOOL, @@ -122,10 +241,10 @@ _Type = _make_enum('DynamicValue.Type', cdef extern from "capnp/list.h" namespace " ::capnp": cdef cppclass List[T]: cppclass Reader: - T operator[](uint) except +ValueError + T operator[](uint) except +reraise_kj_exception uint size() cppclass Builder: - T operator[](uint) except +ValueError + T operator[](uint) except +reraise_kj_exception uint size() cdef extern from "" namespace "std": @@ -138,6 +257,7 @@ cdef extern from "" namespace "std": RemotePromise moveRemotePromise"std::move"(RemotePromise) CallContext moveCallContext"std::move"(CallContext) Own[AsyncIoStream] moveOwnAsyncIOStream"std::move"(Own[AsyncIoStream]) + capnp.Exception moveException"std::move"(capnp.Exception) cdef extern from "" namespace " ::capnp": StringTree printStructReader" ::capnp::prettyPrint"(C_DynamicStruct.Reader) @@ -146,13 +266,6 @@ cdef extern from "" namespace " ::capnp": StringTree printListReader" ::capnp::prettyPrint"(C_DynamicList.Reader) StringTree printListBuilder" ::capnp::prettyPrint"(C_DynamicList.Builder) -cdef extern from "" namespace " ::kj": - String strStructReader" ::kj::str"(C_DynamicStruct.Reader) - String strStructBuilder" ::kj::str"(C_DynamicStruct.Builder) - String strRequest" ::kj::str"(Request &) - String strListReader" ::kj::str"(C_DynamicList.Reader) - String strListBuilder" ::kj::str"(C_DynamicList.Builder) - cdef class _NodeReader: cdef C_Node.Reader thisptr cdef init(self, C_Node.Reader other): @@ -912,7 +1025,7 @@ cdef class _DynamicStructPipeline: def __dealloc__(self): del self.thisptr - cpdef _get(self, field) except +ValueError: + cpdef _get(self, field) except +reraise_kj_exception: cdef int type = (self.thisptr.get(field)).getType() if type == capnp.TYPE_CAPABILITY: return _DynamicCapabilityClient()._init((self.thisptr.get(field)).asCapability(), self._parent) @@ -1042,18 +1155,18 @@ cdef class Promise: def __dealloc__(self): del self.thisptr - cpdef wait(self) except+: + cpdef wait(self) except +reraise_kj_exception: if self.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + raise ValueError('Promise was already used in a consuming operation. You can no longer use this Promise object') ret = self.thisptr.wait() self.is_consumed = True return ret - cpdef then(self, func, error_func=None) except+: + cpdef then(self, func, error_func=None) except +reraise_kj_exception: if self.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + raise ValueError('Promise was already used in a consuming operation. You can no longer use this Promise object') Py_INCREF(func) Py_INCREF(error_func) @@ -1075,15 +1188,15 @@ cdef class _VoidPromise: def __dealloc__(self): del self.thisptr - cpdef wait(self) except+: + cpdef wait(self) except +reraise_kj_exception: if self.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + raise ValueError('Promise was already used in a consuming operation. You can no longer use this Promise object') self.thisptr.wait() self.is_consumed = True - # cpdef then(self, func, error_func=None) except+: + # cpdef then(self, func, error_func=None) except +reraise_kj_exception: # if self.is_consumed: # raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') @@ -1109,28 +1222,28 @@ cdef class _RemotePromise: def __dealloc__(self): del self.thisptr - cpdef wait(self) except+: + cpdef wait(self) except +reraise_kj_exception: if self.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + raise ValueError('Promise was already used in a consuming operation. You can no longer use this Promise object') ret = _DynamicStructReader()._init(self.thisptr.wait(), self._parent) self.is_consumed = True return ret - cpdef as_pypromise(self) except +: + cpdef as_pypromise(self) except +reraise_kj_exception: Promise()._init(convert_to_pypromise(deref(self.thisptr))) - cpdef then(self, func, error_func=None) except+: + cpdef then(self, func, error_func=None) except +reraise_kj_exception: if self.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + raise ValueError('Promise was already used in a consuming operation. You can no longer use this Promise object') Py_INCREF(func) Py_INCREF(error_func) return _VoidPromise()._init(capnp.then(deref(self.thisptr), func, error_func)) - cpdef _get(self, field) except +ValueError: + cpdef _get(self, field) except +reraise_kj_exception: cdef int type = (self.thisptr.get(field)).getType() if type == capnp.TYPE_CAPABILITY: return _DynamicCapabilityClient()._init((self.thisptr.get(field)).asCapability(), self._parent) @@ -1167,11 +1280,22 @@ cdef class EventLoop: Py_INCREF(func) return Promise()._init(capnp.evalLater(self.thisptr, func)) - cpdef wait(self, _RemotePromise promise) except +: + cpdef wait(self, _PromiseTypes promise) except +reraise_kj_exception: if promise.is_consumed: - raise RuntimeError('Promise was already used in a consuming operation. You can no longer use this Promise object') + raise ValueError('Promise was already used in a consuming operation. You can no longer use this Promise object') + + ret = None + if _PromiseTypes is _RemotePromise: + ret = _Response()._init_child(self.thisptr.wait_remote(moveRemotePromise(deref(promise.thisptr))), promise._parent) + elif _PromiseTypes is _VoidPromise: + self.thisptr.wait_void(moveVoidPromise(deref(promise.thisptr))) + elif _PromiseTypes is PromiseFulfillerPair: + self.thisptr.wait_void(moveVoidPromise(deref(promise.thisptr).promise)) + elif _PromiseTypes is Promise: + ret = self.thisptr.wait(movePromise(deref(promise.thisptr))) + else: + raise ValueError("Not a valid promise type") - ret = _Response()._init_child(self.thisptr.wait_remote(moveRemotePromise(deref(promise.thisptr))), promise._parent) promise.is_consumed = True return ret @@ -1244,7 +1368,7 @@ cdef class _DynamicCapabilityClient: self._server = server return self - cpdef _send_helper(self, name, firstSegmentWordSize, kwargs) except +ValueError: + cpdef _send_helper(self, name, firstSegmentWordSize, kwargs) except +reraise_kj_exception: cdef Request * request = new Request(self.thisptr.newRequest(name, firstSegmentWordSize)) for key, val in kwargs.items(): @@ -1252,7 +1376,7 @@ cdef class _DynamicCapabilityClient: return _RemotePromise()._init(request.send(), self) - cpdef _request_helper(self, name, firstSegmentWordSize=0) except +ValueError: + cpdef _request_helper(self, name, firstSegmentWordSize=0) except +reraise_kj_exception: return _Request()._init_child(self.thisptr.newRequest(name, firstSegmentWordSize), self) def _request(self, name, firstSegmentWordSize=0): @@ -1267,7 +1391,7 @@ cdef class _DynamicCapabilityClient: return _partial(self._request, short_name) return _partial(self._send, name) - cpdef upcast(self, schema) except+: + cpdef upcast(self, schema) except +reraise_kj_exception: cdef _InterfaceSchema s if hasattr(schema, 'schema'): s = schema.schema @@ -1276,7 +1400,7 @@ cdef class _DynamicCapabilityClient: return _DynamicCapabilityClient()._init(self.thisptr.upcast(s.thisptr), self._parent) - cpdef cast_as(self, schema) except+: + cpdef cast_as(self, schema) except +reraise_kj_exception: cdef _InterfaceSchema s if hasattr(schema, 'schema'): s = schema.schema @@ -1342,10 +1466,11 @@ cdef class _TwoPartyVatNetwork: cdef class RpcClient: cdef RpcSystem * thisptr cdef public _TwoPartyVatNetwork network - cdef public object loop, restorer + cdef public object loop, restorer, stream def __init__(self, EventLoop loop, FdAsyncIoStream stream, Restorer restorer=None): self.loop = loop + self.stream = stream self.network = _TwoPartyVatNetwork()._init(loop, deref(stream.thisptr), capnp.CLIENT) if restorer is None: self.thisptr = new RpcSystem(makeRpcClient(deref(self.network.thisptr), loop.thisptr)) @@ -1356,7 +1481,7 @@ cdef class RpcClient: def __dealloc__(self): del self.thisptr - cpdef restore(self, objectId) except+: + cpdef restore(self, objectId) except +reraise_kj_exception: cdef _MessageBuilder builder cdef _MessageReader reader @@ -1380,10 +1505,11 @@ cdef class RpcClient: cdef class RpcServer: cdef RpcSystem * thisptr cdef public _TwoPartyVatNetwork network - cdef public object loop, restorer + cdef public object loop, restorer, stream def __init__(self, EventLoop loop, FdAsyncIoStream stream, Restorer restorer): self.loop = loop + self.stream = stream self.restorer = restorer self.network = _TwoPartyVatNetwork()._init(loop, deref(stream.thisptr), capnp.SERVER) self.thisptr = new RpcSystem(makeRpcServer(deref(self.network.thisptr), deref(restorer.thisptr), loop.thisptr)) @@ -1391,12 +1517,25 @@ cdef class RpcServer: def __dealloc__(self): del self.thisptr + # TODO: add restore functionality here? + cdef class FdAsyncIoStream: cdef Own[AsyncIoStream] thisptr def __init__(self, int fd): self.thisptr = AsyncIoStream_wrapFd(fd) +cdef class PromiseFulfillerPair: + cdef Own[C_PromiseFulfillerPair] thisptr + cdef public bint is_consumed + + def __init__(self, EventLoop loop=None): + if loop is None: + self.thisptr = copyPromiseFulfillerPair(newPromiseAndFulfiller()) + else: + self.thisptr = copyPromiseFulfillerPair(newPromiseAndFulfiller(loop.thisptr)) + self.is_consumed = False + cdef class _Schema: cdef C_Schema thisptr cdef _init(self, C_Schema other): diff --git a/capnp/capnp_cpp.pxd b/capnp/capnp_cpp.pxd index 3d06528..fb61d8b 100644 --- a/capnp/capnp_cpp.pxd +++ b/capnp/capnp_cpp.pxd @@ -9,24 +9,34 @@ from libc.stdint cimport * ctypedef unsigned int uint from libcpp cimport bool as cbool +cdef extern from "capabilityHelper.h": + void reraise_kj_exception() + cdef extern from "capnp/common.h" namespace " ::capnp": enum Void: VOID " ::capnp::VOID" -cdef extern from "kj/exception.h" namespace " ::kj": - cdef cppclass Exception: - pass - cdef extern from "kj/string.h" namespace " ::kj": cdef cppclass StringPtr: StringPtr(char *) + char* cStr() cdef cppclass String: char* cStr() +cdef extern from "kj/exception.h" namespace " ::kj": + cdef cppclass Exception: + Exception(Exception) + char* getFile() + int getLine() + int getNature() + int getDurability() + StringPtr getDescription() + cdef extern from "kj/memory.h" namespace " ::kj": cdef cppclass Own[T]: T& operator*() Own[TwoPartyVatNetwork] makeTwoPartyVatNetwork" ::kj::heap< ::capnp::TwoPartyVatNetwork>"(EventLoop &, AsyncIoStream& stream, Side) + Own[PromiseFulfillerPair] copyPromiseFulfillerPair" ::kj::heap< ::kj::PromiseFulfillerPair >"(PromiseFulfillerPair&) cdef extern from "kj/string-tree.h" namespace " ::kj": cdef cppclass StringTree: @@ -54,12 +64,12 @@ cdef extern from "kj/async-io.h" namespace " ::kj": cdef extern from "capnp/schema.h" namespace " ::capnp": cdef cppclass Schema: - Node.Reader getProto() except + - StructSchema asStruct() except + - EnumSchema asEnum() except + - ConstSchema asConst() except + - Schema getDependency(uint64_t id) except + - InterfaceSchema asInterface() except + + Node.Reader getProto() except +reraise_kj_exception + StructSchema asStruct() except +reraise_kj_exception + EnumSchema asEnum() except +reraise_kj_exception + ConstSchema asConst() except +reraise_kj_exception + Schema getDependency(uint64_t id) except +reraise_kj_exception + InterfaceSchema asInterface() except +reraise_kj_exception cdef cppclass InterfaceSchema(Schema): cppclass Method: @@ -143,21 +153,21 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef cppclass DynamicStruct: cppclass Reader: - DynamicValueForward.Reader get(char *) except +ValueError - bint has(char *) except +ValueError + DynamicValueForward.Reader get(char *) except +reraise_kj_exception + bint has(char *) except +reraise_kj_exception StructSchema getSchema() Maybe[StructSchema.Field] which() cppclass Builder: Builder() Builder(Builder &) - DynamicValueForward.Builder get(char *) except +ValueError - bint has(char *) except +ValueError - void set(char *, DynamicValueForward.Reader) except +ValueError - DynamicValueForward.Builder init(char *, uint size) except +ValueError - DynamicValueForward.Builder init(char *) except +ValueError + DynamicValueForward.Builder get(char *) except +reraise_kj_exception + bint has(char *) except +reraise_kj_exception + void set(char *, DynamicValueForward.Reader) except +reraise_kj_exception + DynamicValueForward.Builder init(char *, uint size) except +reraise_kj_exception + DynamicValueForward.Builder init(char *) except +reraise_kj_exception StructSchema getSchema() Maybe[StructSchema.Field] which() - void adopt(char *, DynamicOrphan) except +ValueError + void adopt(char *, DynamicOrphan) except +reraise_kj_exception DynamicOrphan disown(char *) DynamicStruct.Reader asReader() cppclass Pipeline: @@ -201,11 +211,11 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef cppclass Request" ::capnp::Request< ::capnp::DynamicStruct, ::capnp::DynamicStruct>": Request() Request(Request &) - DynamicValueForward.Builder get(char *) except +ValueError - bint has(char *) except +ValueError - void set(char *, DynamicValueForward.Reader) except +ValueError - DynamicValueForward.Builder init(char *, uint size) except +ValueError - DynamicValueForward.Builder init(char *) except +ValueError + DynamicValueForward.Builder get(char *) except +reraise_kj_exception + bint has(char *) except +reraise_kj_exception + void set(char *, DynamicValueForward.Reader) except +reraise_kj_exception + DynamicValueForward.Builder init(char *, uint size) except +reraise_kj_exception + DynamicValueForward.Builder init(char *) except +reraise_kj_exception StructSchema getSchema() Maybe[StructSchema.Field] which() RemotePromise send() @@ -219,7 +229,7 @@ cdef extern from "capnp/object.h" namespace " ::capnp": DynamicStruct.Builder getAs"getAs< ::capnp::DynamicStruct>"(StructSchema) cdef extern from "fixMaybe.h": - EnumSchema.Enumerant fixMaybe(Maybe[EnumSchema.Enumerant]) except +ValueError + EnumSchema.Enumerant fixMaybe(Maybe[EnumSchema.Enumerant]) except +reraise_kj_exception char * getEnumString(DynamicStruct.Reader val) char * getEnumString(DynamicStruct.Builder val) char * getEnumString(Request val) @@ -250,16 +260,16 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef cppclass DynamicList: cppclass Reader: - DynamicValueForward.Reader operator[](uint) except +ValueError + DynamicValueForward.Reader operator[](uint) except +reraise_kj_exception uint size() cppclass Builder: Builder() Builder(Builder &) - DynamicValueForward.Builder operator[](uint) except +ValueError + DynamicValueForward.Builder operator[](uint) except +reraise_kj_exception uint size() - void set(uint index, DynamicValueForward.Reader value) except +ValueError - DynamicValueForward.Builder init(uint index, uint size) except +ValueError - void adopt(uint, DynamicOrphan) except +ValueError + void set(uint index, DynamicValueForward.Reader value) except +reraise_kj_exception + DynamicValueForward.Builder init(uint index, uint size) except +reraise_kj_exception + void adopt(uint, DynamicOrphan) except +reraise_kj_exception DynamicOrphan disown(uint) StructSchema getStructElementType'getSchema().getStructElementType'() @@ -321,10 +331,10 @@ cdef extern from "capnp/dynamic.h" namespace " ::capnp": cdef extern from "capnp/schema-parser.h" namespace " ::capnp": cdef cppclass ParsedSchema(Schema): - ParsedSchema getNested(char * name) except + + ParsedSchema getNested(char * name) except +reraise_kj_exception cdef cppclass SchemaParser: SchemaParser() - ParsedSchema parseDiskFile(char * displayName, char * diskPath, ArrayPtr[StringPtr] importPath) except + + ParsedSchema parseDiskFile(char * displayName, char * diskPath, ArrayPtr[StringPtr] importPath) except +reraise_kj_exception cdef extern from "capnp/orphan.h" namespace " ::capnp": cdef cppclass DynamicOrphan" ::capnp::Orphan< ::capnp::DynamicValue>": @@ -334,7 +344,7 @@ cdef extern from "capnp/orphan.h" namespace " ::capnp": cdef extern from "capnp/capability.h" namespace " ::capnp": cdef cppclass CallContext' ::capnp::CallContext< ::capnp::DynamicStruct, ::capnp::DynamicStruct>': CallContext(CallContext&) - DynamicStruct.Reader getParams() except + + DynamicStruct.Reader getParams() except +reraise_kj_exception void releaseParams() DynamicStruct.Builder getResults(uint firstSegmentWordSize) @@ -349,13 +359,21 @@ cdef extern from "kj/async.h" namespace " ::kj": cdef cppclass EventLoop: EventLoop() # Promise[void] yield_end'yield'() - object wait(PyPromise) except+ + object wait(PyPromise) except +reraise_kj_exception Response wait_remote'wait'(RemotePromise) - object there(PyPromise) except+ + void wait_void'wait'(VoidPromise) + object there(PyPromise) except +reraise_kj_exception PyPromise evalLater(PyObject * func) PyPromise there(PyPromise, PyObject * func) cdef cppclass SimpleEventLoop(EventLoop): pass + cdef cppclass PromiseFulfiller: + pass + cdef cppclass PromiseFulfillerPair" ::kj::PromiseFulfillerPair": + VoidPromise promise + Own[PromiseFulfiller] fulfiller + PromiseFulfillerPair newPromiseAndFulfiller" ::kj::newPromiseAndFulfiller"() + PromiseFulfillerPair newPromiseAndFulfiller" ::kj::newPromiseAndFulfiller"(EventLoop&) cdef extern from "kj/async-unix.h" namespace " ::kj": cdef cppclass UnixEventLoop(EventLoop): diff --git a/capnp/schema_cpp.pxd b/capnp/schema_cpp.pxd index bfea2e6..4337587 100644 --- a/capnp/schema_cpp.pxd +++ b/capnp/schema_cpp.pxd @@ -708,22 +708,25 @@ cdef extern from "kj/array.h" namespace " ::kj": word* begin() size_t size() +cdef extern from "capabilityHelper.h": + void reraise_kj_exception() + cdef extern from "capnp/serialize.h" namespace " ::capnp": cdef cppclass StreamFdMessageReader(MessageReader): - StreamFdMessageReader(int) except + - StreamFdMessageReader(int, ReaderOptions) except + + StreamFdMessageReader(int) except +reraise_kj_exception + StreamFdMessageReader(int, ReaderOptions) except +reraise_kj_exception cdef cppclass FlatArrayMessageReader(MessageReader): - FlatArrayMessageReader(WordArrayPtr array) except + - FlatArrayMessageReader(WordArrayPtr array, ReaderOptions) except + + FlatArrayMessageReader(WordArrayPtr array) except +reraise_kj_exception + FlatArrayMessageReader(WordArrayPtr array, ReaderOptions) except +reraise_kj_exception - void writeMessageToFd(int, MessageBuilder&) except + + void writeMessageToFd(int, MessageBuilder&) except +reraise_kj_exception WordArray messageToFlatArray(MessageBuilder &) cdef extern from "capnp/serialize-packed.h" namespace " ::capnp": cdef cppclass PackedFdMessageReader(MessageReader): - PackedFdMessageReader(int) except + - StreamFdMessageReader(int, ReaderOptions) except + + PackedFdMessageReader(int) except +reraise_kj_exception + StreamFdMessageReader(int, ReaderOptions) except +reraise_kj_exception - void writePackedMessageToFd(int, MessageBuilder&) except + + void writePackedMessageToFd(int, MessageBuilder&) except +reraise_kj_exception From c1952a62aec8253cf2e4829fed489bb73a126e7d Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 20:54:57 -0800 Subject: [PATCH 38/43] Fix exception propogation in Promises --- capnp/capabilityHelper.h | 19 +++++++++++++++++-- capnp/capnp.pyx | 9 +++++++++ test/test_capability.py | 6 +++--- 3 files changed, 29 insertions(+), 5 deletions(-) diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index 8a314ab..e1e3294 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -11,6 +11,7 @@ extern "C" { ::kj::Promise * call_server_method(PyObject * py_server, char * name, capnp::CallContext< capnp::DynamicStruct, capnp::DynamicStruct> & context); PyObject * wrap_kj_exception(kj::Exception &); PyObject * wrap_kj_exception_for_reraise(kj::Exception &); + PyObject * get_exception_info(PyObject *, PyObject *, PyObject *); } void reraise_kj_exception() { @@ -36,8 +37,22 @@ void reraise_kj_exception() { void check_py_error() { PyObject * err = PyErr_Occurred(); if(err) { - // PyErr_Clear(); - throw std::exception(); + // TODO: decref references + PyObject * ptype, *pvalue, *ptraceback; + PyErr_Fetch(&ptype, &pvalue, &ptraceback); + + PyObject * info = get_exception_info(ptype, pvalue, ptraceback); + + PyObject * py_filename = PyTuple_GetItem(info, 0); + kj::String filename(kj::heapString(PyBytes_AsString(py_filename))); + + PyObject * py_line = PyTuple_GetItem(info, 1); + int line = PyInt_AsLong(py_line); + + PyObject * py_description = PyTuple_GetItem(info, 2); + kj::String description(kj::heapString(PyBytes_AsString(py_description))); + + throw kj::Exception(kj::Exception::Nature::OTHER, kj::Exception::Durability::PERMANENT, kj::mv(filename), line, kj::mv(description)); } } diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index ca2ca18..20f902c 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -16,6 +16,7 @@ from cython.operator cimport dereference as deref cimport async_cpp from cpython.ref cimport PyObject, Py_INCREF, Py_DECREF +from cpython.exc cimport PyErr_Clear from libc.stdint cimport * ctypedef unsigned int uint ctypedef uint8_t UInt8 @@ -181,6 +182,7 @@ class KjException(Exception): return self.message cdef public object wrap_kj_exception(capnp.Exception & exception): + PyErr_Clear() wrapper = _KjExceptionWrapper()._init(exception) ret = KjException(wrapper=wrapper) @@ -204,6 +206,13 @@ cdef public object wrap_kj_exception_for_reraise(capnp.Exception & exception): ret = KjException(wrapper=wrapper) return ret +cdef public object get_exception_info(object exc_type, object exc_obj, object exc_tb): + try: + return (exc_tb.tb_frame.f_code.co_filename, exc_tb.tb_lineno, repr(exc_type) + ':' + str(exc_obj)) + except: + return ('', 0, "Couldn't determine python exception") + + ctypedef fused _DynamicStructReaderOrBuilder: _DynamicStructReader _DynamicStructBuilder diff --git a/test/test_capability.py b/test/test_capability.py index 230abaa..100a994 100644 --- a/test/test_capability.py +++ b/test/test_capability.py @@ -113,7 +113,7 @@ def test_exception_client(capability): client = capability.TestInterface.new_client(BadServer(), loop) remote = client._send('foo', i=5) - with pytest.raises(ValueError): + with pytest.raises(capnp.KjException): loop.wait(remote) class BadPipelineServer: @@ -122,7 +122,7 @@ class BadPipelineServer: context.results.s = response.x + '_foo' context.results.outBox.cap = capability().TestInterface.new_server(Server(100)) def _error(error): - raise Exception('test') + raise Exception('test was a success') return context.params.inCap.foo(i=context.params.n).then(_then, _error) @@ -137,7 +137,7 @@ def test_exception_chain(capability): try: loop.wait(remote) except Exception as e: - assert str(e) == 'test' + assert 'test was a success' in str(e) def test_pipeline_exception(capability): loop = capnp.EventLoop() From 422266d0b8a2c3e08448e04fc894abe0e1cc840e Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 21:02:22 -0800 Subject: [PATCH 39/43] Fix str output in test with updated format --- test/all-types.txt | 132 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 124 insertions(+), 8 deletions(-) diff --git a/test/all-types.txt b/test/all-types.txt index e0910d3..079ff8d 100644 --- a/test/all-types.txt +++ b/test/all-types.txt @@ -1,4 +1,5 @@ -( boolField = true, +( voidField = void, + boolField = true, int8Field = -123, int16Field = -12345, int32Field = -12345678, @@ -12,6 +13,7 @@ textField = "foo", dataField = "bar", structField = ( + voidField = void, boolField = true, int8Field = -12, int16Field = 3456, @@ -26,10 +28,39 @@ textField = "baz", dataField = "qux", structField = ( + voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, textField = "nested", structField = ( - textField = "really nested" ) ), + voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "really nested", + enumField = foo, + interfaceField = void ), + enumField = foo, + interfaceField = void ), enumField = baz, + interfaceField = void, voidList = [void, void, void], boolList = [false, true, false, true, true], int8List = [12, -34, -128, 127], @@ -45,11 +76,54 @@ textList = ["quux", "corge", "grault"], dataList = ["garply", "waldo", "fred"], structList = [ - ( textField = "x structlist 1" ), - ( textField = "x structlist 2" ), - ( textField = "x structlist 3" ) ], + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "x structlist 1", + enumField = foo, + interfaceField = void ), + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "x structlist 2", + enumField = foo, + interfaceField = void ), + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "x structlist 3", + enumField = foo, + interfaceField = void ) ], enumList = [qux, bar, grault] ), enumField = corge, + interfaceField = void, voidList = [void, void, void, void, void, void], boolList = [true, false, false, true], int8List = [111, -111], @@ -65,7 +139,49 @@ textList = ["plugh", "xyzzy", "thud"], dataList = ["oops", "exhausted", "rfc3092"], structList = [ - ( textField = "structlist 1" ), - ( textField = "structlist 2" ), - ( textField = "structlist 3" ) ], + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "structlist 1", + enumField = foo, + interfaceField = void ), + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "structlist 2", + enumField = foo, + interfaceField = void ), + ( voidField = void, + boolField = false, + int8Field = 0, + int16Field = 0, + int32Field = 0, + int64Field = 0, + uInt8Field = 0, + uInt16Field = 0, + uInt32Field = 0, + uInt64Field = 0, + float32Field = 0, + float64Field = 0, + textField = "structlist 3", + enumField = foo, + interfaceField = void ) ], enumList = [foo, garply] ) From 56d5ea688ec85a2afee541d4ed048d1f95cfdd7d Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 21:02:43 -0800 Subject: [PATCH 40/43] Fix refcounting for exception handling --- capnp/capabilityHelper.h | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/capnp/capabilityHelper.h b/capnp/capabilityHelper.h index e1e3294..0628c50 100644 --- a/capnp/capabilityHelper.h +++ b/capnp/capabilityHelper.h @@ -37,7 +37,6 @@ void reraise_kj_exception() { void check_py_error() { PyObject * err = PyErr_Occurred(); if(err) { - // TODO: decref references PyObject * ptype, *pvalue, *ptraceback; PyErr_Fetch(&ptype, &pvalue, &ptraceback); @@ -52,6 +51,12 @@ void check_py_error() { PyObject * py_description = PyTuple_GetItem(info, 2); kj::String description(kj::heapString(PyBytes_AsString(py_description))); + Py_DECREF(ptype); + Py_DECREF(pvalue); + Py_DECREF(ptraceback); + Py_DECREF(info); + PyErr_Clear(); + throw kj::Exception(kj::Exception::Nature::OTHER, kj::Exception::Durability::PERMANENT, kj::mv(filename), line, kj::mv(description)); } } From 64619758ab16cca25ed04105375a1e8522dc7067 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 21:14:46 -0800 Subject: [PATCH 41/43] Fix bug in python3 due to improper string handling --- capnp/capnp.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 20f902c..6200410 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -208,9 +208,9 @@ cdef public object wrap_kj_exception_for_reraise(capnp.Exception & exception): cdef public object get_exception_info(object exc_type, object exc_obj, object exc_tb): try: - return (exc_tb.tb_frame.f_code.co_filename, exc_tb.tb_lineno, repr(exc_type) + ':' + str(exc_obj)) + return (exc_tb.tb_frame.f_code.co_filename.encode(), exc_tb.tb_lineno, (repr(exc_type) + ':' + str(exc_obj)).encode()) except: - return ('', 0, "Couldn't determine python exception") + return (b'', 0, b"Couldn't determine python exception") ctypedef fused _DynamicStructReaderOrBuilder: From 7d82dcbfd859ce1b81e553b9299fdf122bb2e14d Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 21:52:50 -0800 Subject: [PATCH 42/43] Update examples for RPC --- examples/example_client.cpp | 59 +++++++++++++++++++++++++++++++++++++ examples/example_client.py | 3 +- examples/example_server.py | 39 ++++++++++++++++++++++++ 3 files changed, 100 insertions(+), 1 deletion(-) create mode 100644 examples/example_client.cpp create mode 100644 examples/example_server.py diff --git a/examples/example_client.cpp b/examples/example_client.cpp new file mode 100644 index 0000000..0a20e80 --- /dev/null +++ b/examples/example_client.cpp @@ -0,0 +1,59 @@ +#include "capnp/rpc-twoparty.h" +#include +#include +#include "test.capnp.h" +#include +#include + +using namespace capnp; +using namespace capnproto_test::capnp; +using namespace kj; + +Capability::Client getPersistentCap(RpcSystem& client, + rpc::twoparty::Side side, + test::TestSturdyRefObjectId::Tag tag) { + // Create the SturdyRefHostId. + MallocMessageBuilder hostIdMessage(8); + auto hostId = hostIdMessage.initRoot(); + hostId.setSide(side); + + // Create the SturdyRefObjectId. + MallocMessageBuilder objectIdMessage(8); + objectIdMessage.initRoot().setTag(tag); + + // Connect to the remote capability. + return client.restore(hostId, objectIdMessage.getRoot()); +} + +int main() +{ + try + { + kj::UnixEventLoop loop; + auto result = loop.evalLater([&]() { + auto network = Network::newSystemNetwork(); + auto address = loop.wait(network->parseRemoteAddress("127.0.0.1:49999")); + auto stream = loop.wait(address->connect()); + TwoPartyVatNetwork vat(loop, *stream, rpc::twoparty::Side::CLIENT); + auto rpcClient = makeRpcClient(vat, loop); + + // Request the particular capability from the server. + auto client = getPersistentCap(rpcClient, rpc::twoparty::Side::SERVER, + test::TestSturdyRefObjectId::Tag::TEST_INTERFACE).castAs(); + + auto request1 = client.fooRequest(); + request1.setI(5); + auto promise1 = request1.send(); + auto response1 = loop.wait(kj::mv(promise1)); + + assert ("125" == response1.getX()); + }); + + loop.wait(kj::mv(result)); + } + catch (std::exception& e) + { + std::cerr << e.what() << std::endl; + } + return 0; +} \ No newline at end of file diff --git a/examples/example_client.py b/examples/example_client.py index 90c65c3..740b125 100644 --- a/examples/example_client.py +++ b/examples/example_client.py @@ -20,6 +20,7 @@ def example_client(): remote = cap.foo(i=5) response = loop.wait(remote) - assert response.x == 'foo' + assert response.x == '125' + c.close() example_client() \ No newline at end of file diff --git a/examples/example_server.py b/examples/example_server.py new file mode 100644 index 0000000..1f82e1d --- /dev/null +++ b/examples/example_server.py @@ -0,0 +1,39 @@ +import capnp +import test_capnp + +import socket +import traceback + +class Server: + def __init__(self, val=1): + self.val = val + + def foo(self, context): + context.results.x = str(context.params.i * 5 + self.val) + +def restore(ref_id): + return test_capnp.TestInterface.new_server(Server(100)) + +def example_server(host='localhost', port=49999): + backlog = 1 + + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.bind((host,port)) + s.listen(backlog) + + loop = capnp.EventLoop() + while 1: + try: + (clientsocket, address) = s.accept() + stream = capnp.FdAsyncIoStream(clientsocket.fileno()) + restorer = capnp.Restorer(test_capnp.TestSturdyRefObjectId, restore) + server = capnp.RpcServer(loop, stream, restorer) + + waiter = capnp.PromiseFulfillerPair() + loop.wait(waiter) + except KeyboardInterrupt: + break + except: + traceback.print_exc() + +example_server() \ No newline at end of file From ecd2666f96632327a649043bd4fe3a13f81ddf87 Mon Sep 17 00:00:00 2001 From: Jason Paryani Date: Wed, 13 Nov 2013 22:14:29 -0800 Subject: [PATCH 43/43] Add missing exception handler on to_bytes --- capnp/capnp.pyx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/capnp/capnp.pyx b/capnp/capnp.pyx index 6200410..7e04386 100644 --- a/capnp/capnp.pyx +++ b/capnp/capnp.pyx @@ -869,7 +869,7 @@ cdef class _DynamicStructBuilder: _write_packed_message_to_fd(file.fileno(), self._parent) self._is_written = True - def to_bytes(_DynamicStructBuilder self): + cpdef to_bytes(_DynamicStructBuilder self) except +reraise_kj_exception: """Returns the struct's containing message as a Python bytes object in the unpacked binary format. This is inefficient; it makes several copies.