diff --git a/compiler/pom.xml b/compiler/pom.xml index 3af6c4d..3fcafa3 100644 --- a/compiler/pom.xml +++ b/compiler/pom.xml @@ -39,7 +39,6 @@ 4.13.1 test - org.capnproto runtime @@ -79,7 +78,6 @@ run - generate-test-sources generate-test-sources @@ -94,6 +92,7 @@ + diff --git a/compiler/src/main/cpp/capnpc-java.c++ b/compiler/src/main/cpp/capnpc-java.c++ index 551c422..0a77097 100644 --- a/compiler/src/main/cpp/capnpc-java.c++ +++ b/compiler/src/main/cpp/capnpc-java.c++ @@ -198,6 +198,7 @@ private: SchemaLoader schemaLoader; std::unordered_set usedImports; bool hasInterfaces = false; + bool liteMode = false; kj::StringTree javaFullName(Schema schema, kj::Maybe method = nullptr) { auto node = schema.getProto(); @@ -334,6 +335,9 @@ private: } } case schema::Type::INTERFACE: { + if (liteMode) { + return kj::strTree("org.capnproto.Capability.", suffix); + } auto interfaceSchema = type.asInterface(); if (interfaceSchema.getProto().getIsGeneric()) { auto typeArgs = getTypeArguments(interfaceSchema, interfaceSchema, kj::str(suffix)); @@ -912,8 +916,13 @@ private: spaces(indent), " }\n", "\n"), - // TODO pipelineMethodDecls - kj::strTree() + (hasDiscriminantValue(proto) || liteMode) + ? kj::strTree() + : kj::strTree( + spaces(indent), " default ", titleCase, ".Pipeline get", titleCase, "() {\n", + spaces(indent), " var pipeline = this.typelessPipeline().noop();\n", + spaces(indent), " return () -> pipeline;\n", + spaces(indent), " }\n") }; } } @@ -1087,6 +1096,9 @@ private: }; } else if (kind == FieldKind::INTERFACE) { + if (liteMode) { + return {}; + } auto factoryArg = makeFactoryArg(field.getType()); auto clientType = typeName(field.getType(), kj::str("Client")).flatten(); auto serverType = typeName(field.getType(), kj::str("Server")).flatten(); @@ -1258,7 +1270,7 @@ private: spaces(indent), " }\n"), // Pipeline accessors - (field.getType().asStruct().getProto().getIsGeneric() + ((liteMode || field.getType().asStruct().getProto().getIsGeneric()) ? kj::strTree() // No generics for you, sorry. : kj::strTree( spaces(indent), " default ", pipelineType, " get", titleCase, "() {\n", @@ -1667,11 +1679,14 @@ private: spaces(indent), " _NOT_IN_SCHEMA,\n", spaces(indent), " }\n"), KJ_MAP(n, nestedTypeDecls) { return kj::mv(n); }, - spaces(indent), " public interface Pipeline", readerTypeParams, " extends org.capnproto.Pipeline {\n", - KJ_MAP(f, fieldTexts) { - return kj::mv(f.pipelineMethodDecls); - }, - spaces(indent), " }\n", + (liteMode ? kj::strTree() + : kj::strTree( + spaces(indent), " public interface Pipeline", readerTypeParams, " extends org.capnproto.Pipeline {\n", + KJ_MAP(f, fieldTexts) { + return kj::mv(f.pipelineMethodDecls); + }, + spaces(indent), " }\n") + ), spaces(indent), "}\n"), kj::strTree(), @@ -1703,6 +1718,10 @@ private: InterfaceText makeInterfaceText(kj::StringPtr scope, kj::StringPtr name, InterfaceSchema schema, kj::Array nestedTypeDecls, int indent) { + if (liteMode) { + return {}; + } + auto sp = spaces(indent); auto fullName = kj::str(scope, name); auto methods = KJ_MAP(m, schema.getMethods()) { @@ -2499,6 +2518,11 @@ private: } kj::MainBuilder::Validity run() { + + if (::getenv("CAPNP_LITE") != nullptr) { + liteMode = true; + } + ReaderOptions options; options.traversalLimitInWords = 1 << 30; // Don't limit. StreamFdMessageReader reader(STDIN_FILENO, options); diff --git a/gen b/gen index 6fd2d73..dad800b 100755 --- a/gen +++ b/gen @@ -8,18 +8,20 @@ make CXX=g++-8 capnpc-java capnp compile -I./compiler/src/main/schema/ -o/bin/cat ./runtime/src/test/schema/test.capnp > ./runtime/src/test/schema/test.raw capnp compile -I./compiler/src/main/schema/ -oc++ ./runtime/src/test/schema/test.capnp -capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./runtime/src/test/schema/test.capnp -cp ./runtime/src/test/schema/Test.java ./runtime/src/test/java/org/capnproto/test/ +env CAPNP_LITE=1 capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./runtime/src/test/schema/test.capnp +cp ./runtime/src/test/schema/Test.java ./runtime/src/test/schema/TestLite.java +capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./runtime/src/test/schema/test.capnp +#cp ./runtime/src/test/schema/Test.java ./runtime/src/test/java/org/capnproto/test/ -capnp compile -I./compiler/src/main/schema/ -oc++ ./runtime/src/test/schema/demo.capnp -capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./runtime/src/test/schema/demo.capnp -cp ./runtime/src/test/schema/Demo.java ./runtime/src/test/java/org/capnproto/demo/ +#capnp compile -I./compiler/src/main/schema/ -oc++ ./runtime/src/test/schema/demo.capnp +#capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./runtime/src/test/schema/demo.capnp +#cp ./runtime/src/test/schema/Demo.java ./runtime/src/test/java/org/capnproto/demo/ -capnp compile -I./compiler/src/main/schema/ -o/bin/cat ./runtime/src/test/schema/generics.capnp > ./runtime/src/test/schema/generics.raw -capnp compile -I./compiler/src/main/schema/ -oc++ ./runtime/src/test/schema/generics.capnp -capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./runtime/src/test/schema/generics.capnp -cp ./runtime/src/test/schema/TestGenerics.java ./runtime/src/test/java/org/capnproto/demo/ +#capnp compile -I./compiler/src/main/schema/ -o/bin/cat ./runtime/src/test/schema/generics.capnp > ./runtime/src/test/schema/generics.raw +#capnp compile -I./compiler/src/main/schema/ -oc++ ./runtime/src/test/schema/generics.capnp +#capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./runtime/src/test/schema/generics.capnp +#cp ./runtime/src/test/schema/TestGenerics.java ./runtime/src/test/java/org/capnproto/demo/ -capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./examples/src/main/schema/addressbook.capnp -cp ./examples/src/main/schema/Addressbook.java ./examples/src/main/java/org/capnproto/examples/ +#capnp compile -I./compiler/src/main/schema/ -o./capnpc-java ./examples/src/main/schema/addressbook.capnp +#cp ./examples/src/main/schema/Addressbook.java ./examples/src/main/java/org/capnproto/examples/ diff --git a/pom.xml b/pom.xml index 83fd696..10d5c2b 100644 --- a/pom.xml +++ b/pom.xml @@ -12,6 +12,7 @@ compiler examples benchmark + runtime-rpc diff --git a/runtime-rpc/pom.xml b/runtime-rpc/pom.xml new file mode 100644 index 0000000..29b5bd4 --- /dev/null +++ b/runtime-rpc/pom.xml @@ -0,0 +1,228 @@ + + + 4.0.0 + org.capnproto + runtime-rpc + jar + runtime-rpc + 0.1.6-SNAPSHOT + Cap'n Proto runtime library + + org.capnproto + + https://capnproto.org/ + + + MIT + http://opensource.org/licenses/MIT + repo + + + + git@github.com:capnproto/capnproto-java.git + scm:git@github.com:capnproto/capnproto-java.git + + + + dwrensha + David Renshaw + https://github.com/dwrensha + + + vaci + Vaci Koblizek + https://github.com/vaci + + + + UTF-8 + + + + junit + junit + 4.13.1 + test + + + org.capnproto + runtime + 0.1.6-SNAPSHOT + + + org.capnproto + compiler + 0.1.6-SNAPSHOT + + + + + + ossrh + https://oss.sonatype.org/content/repositories/snapshots + + + ossrh + https://oss.sonatype.org/service/local/staging/deploy/maven2/ + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.3 + + -Xlint:unchecked + 14 + 14 + + + + + maven-antrun-plugin + 3.0.0 + + + generate-rpc-sources + generate-sources + + + + + + + + + + + + + + + + + run + + + + generate-rpc-test-sources + generate-test-sources + + + + + + + + + + + + + + + run + + + + + + org.codehaus.mojo + build-helper-maven-plugin + 3.1.0 + + + add-generated-sources + generate-sources + + add-source + + + + src/main/generated + + + + + add-generated-test-sources + generate-test-sources + + add-test-source + + + + src/test/generated + + + + + + + + + + + release + + + + org.apache.maven.plugins + maven-source-plugin + 2.2.1 + + + attach-sources + + jar-no-fork + + + + + + org.apache.maven.plugins + maven-javadoc-plugin + 2.10.3 + + + attach-javadocs + + jar + + + false + + + + + + maven-gpg-plugin + 1.6 + + + sign-artifacts + verify + + sign + + + + + + org.sonatype.plugins + nexus-staging-maven-plugin + 1.6.6 + true + + ossrh + https://oss.sonatype.org/ + true + + + + + + + + \ No newline at end of file diff --git a/runtime/src/main/java/org/capnproto/RpcDumper.java b/runtime-rpc/src/main/java/org/capnproto/RpcDumper.java similarity index 100% rename from runtime/src/main/java/org/capnproto/RpcDumper.java rename to runtime-rpc/src/main/java/org/capnproto/RpcDumper.java diff --git a/runtime/src/main/java/org/capnproto/RpcState.java b/runtime-rpc/src/main/java/org/capnproto/RpcState.java similarity index 96% rename from runtime/src/main/java/org/capnproto/RpcState.java rename to runtime-rpc/src/main/java/org/capnproto/RpcState.java index 8f1c3a8..0eb4fb5 100644 --- a/runtime/src/main/java/org/capnproto/RpcState.java +++ b/runtime-rpc/src/main/java/org/capnproto/RpcState.java @@ -346,7 +346,7 @@ final class RpcState { int sizeHint = messageSizeHint() + exceptionSizeHint(exc); var message = this.connection.newOutgoingMessage(sizeHint); var abort = message.getBody().getAs(RpcProtocol.Message.factory).initAbort(); - RpcException.fromException(exc, abort); + FromException(exc, abort); message.send(); } catch (Throwable abortFailed) { @@ -511,7 +511,7 @@ final class RpcState { } void handleAbort(RpcProtocol.Exception.Reader abort) throws RpcException { - throw RpcException.toException(abort); + throw ToException(abort); } void handleBootstrap(IncomingRpcMessage message, RpcProtocol.Bootstrap.Reader bootstrap) { @@ -538,7 +538,7 @@ final class RpcState { var payload = ret.initResults(); var content = payload.getContent().imbue(capTable); var cap = this.bootstrapFactory.createFor(connection.getPeerVatId()); - content.setAsCap(cap); + content.setAs(Capability.factory, cap); var caps = capTable.getTable(); var capHook = caps.length != 0 ? caps[0] @@ -676,7 +676,7 @@ final class RpcState { assert false: "Tail call `Return` must set `resultsSentElsewhere`, not `exception`."; break; } - question.reject(RpcException.toException(callReturn.getException())); + question.reject(ToException(callReturn.getException())); break; case CANCELED: @@ -752,7 +752,7 @@ final class RpcState { cap = receiveCap(resolve.getCap(), message.getAttachedFds()); break; case EXCEPTION: - exc = RpcException.toException(resolve.getException()); + exc = ToException(resolve.getException()); break; default: assert false: "Unknown 'Resolve' type."; @@ -976,7 +976,7 @@ final class RpcState { var message = connection.newOutgoingMessage(sizeHint); var resolve = message.getBody().initAs(RpcProtocol.Message.factory).initResolve(); resolve.setPromiseId(exportId); - RpcException.fromException(exc, resolve.initException()); + FromException(exc, resolve.initException()); message.send(); // TODO disconnect? @@ -1053,7 +1053,7 @@ final class RpcState { case RECEIVER_ANSWER: var promisedAnswer = descriptor.getReceiverAnswer(); var answer = answers.find(promisedAnswer.getQuestionId()); - var ops = PipelineOp.ToPipelineOps(promisedAnswer); + var ops = ToPipelineOps(promisedAnswer); if (answer == null || !answer.active || answer.pipeline == null || ops == null) { return Capability.newBrokenCap("invalid 'receiverAnswer'"); @@ -1158,7 +1158,7 @@ final class RpcState { RpcException.failed("Pipeline call on a request that returned no capabilities or was already closed.")); } - var ops = PipelineOp.ToPipelineOps(promisedAnswer); + var ops = ToPipelineOps(promisedAnswer); if (ops == null) { return null; } @@ -1404,7 +1404,7 @@ final class RpcState { var builder = message.getBody().initAs(RpcProtocol.Message.factory).initReturn(); builder.setAnswerId(this.answerId); builder.setReleaseParamCaps(false); - RpcException.fromException(exc, builder.initException()); + FromException(exc, builder.initException()); message.send(); } @@ -1891,7 +1891,7 @@ final class RpcState { public Integer writeDescriptor(RpcProtocol.CapDescriptor.Builder descriptor, List fds) { var promisedAnswer = descriptor.initReceiverAnswer(); promisedAnswer.setQuestionId(question.getId()); - PipelineOp.FromPipelineOps(ops, promisedAnswer); + FromPipelineOps(ops, promisedAnswer); return null; } @@ -1899,8 +1899,66 @@ final class RpcState { public ClientHook writeTarget(RpcProtocol.MessageTarget.Builder target) { var builder = target.initPromisedAnswer(); builder.setQuestionId(question.getId()); - PipelineOp.FromPipelineOps(ops, builder); + FromPipelineOps(ops, builder); return null; } } + + static void FromPipelineOps(PipelineOp[] ops, RpcProtocol.PromisedAnswer.Builder builder) { + var transforms = builder.initTransform(ops.length); + for (int ii = 0; ii < ops.length; ++ii) { + switch (ops[ii].type) { + case NOOP: + transforms.get(ii).setNoop(null); + break; + case GET_POINTER_FIELD: + transforms.get(ii).setGetPointerField(ops[ii].pointerIndex); + break; + } + } + } + + static PipelineOp[] ToPipelineOps(RpcProtocol.PromisedAnswer.Reader reader) { + var transforms = reader.getTransform(); + var ops = new PipelineOp[transforms.size()]; + for (int ii = 0; ii < ops.length; ++ii) { + var transform = transforms.get(ii); + switch (transform.which()) { + case NOOP: + ops[ii] = PipelineOp.Noop(); // TODO null? + break; + case GET_POINTER_FIELD: + ops[ii] = PipelineOp.PointerField(transform.getGetPointerField()); + break; + default: + // TODO improve error handling here + // Unsupported pipeline ops + return null; + } + } + return ops; + } + + static void FromException(Throwable exc, RpcProtocol.Exception.Builder builder) { + builder.setReason(exc.getMessage()); + builder.setType(RpcProtocol.Exception.Type.FAILED); + } + + static RpcException ToException(RpcProtocol.Exception.Reader reader) { + var type = RpcException.Type.UNKNOWN; + + switch (reader.getType()) { + case UNIMPLEMENTED: + type = RpcException.Type.UNIMPLEMENTED; + break; + case FAILED: + type = RpcException.Type.FAILED; + break; + case DISCONNECTED: + case OVERLOADED: + default: + break; + } + return new RpcException(type, reader.getReason().toString()); + } } diff --git a/runtime/src/main/java/org/capnproto/RpcSystem.java b/runtime-rpc/src/main/java/org/capnproto/RpcSystem.java similarity index 100% rename from runtime/src/main/java/org/capnproto/RpcSystem.java rename to runtime-rpc/src/main/java/org/capnproto/RpcSystem.java diff --git a/runtime/src/main/java/org/capnproto/TwoPartyClient.java b/runtime-rpc/src/main/java/org/capnproto/TwoPartyClient.java similarity index 100% rename from runtime/src/main/java/org/capnproto/TwoPartyClient.java rename to runtime-rpc/src/main/java/org/capnproto/TwoPartyClient.java diff --git a/runtime/src/main/java/org/capnproto/TwoPartyServer.java b/runtime-rpc/src/main/java/org/capnproto/TwoPartyServer.java similarity index 99% rename from runtime/src/main/java/org/capnproto/TwoPartyServer.java rename to runtime-rpc/src/main/java/org/capnproto/TwoPartyServer.java index 1c8840f..5503b0a 100644 --- a/runtime/src/main/java/org/capnproto/TwoPartyServer.java +++ b/runtime-rpc/src/main/java/org/capnproto/TwoPartyServer.java @@ -6,7 +6,6 @@ import java.nio.channels.CompletionHandler; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CompletionStage; public class TwoPartyServer { diff --git a/runtime/src/main/java/org/capnproto/TwoPartyVatNetwork.java b/runtime-rpc/src/main/java/org/capnproto/TwoPartyVatNetwork.java similarity index 99% rename from runtime/src/main/java/org/capnproto/TwoPartyVatNetwork.java rename to runtime-rpc/src/main/java/org/capnproto/TwoPartyVatNetwork.java index 68a425b..2c86606 100644 --- a/runtime/src/main/java/org/capnproto/TwoPartyVatNetwork.java +++ b/runtime-rpc/src/main/java/org/capnproto/TwoPartyVatNetwork.java @@ -4,7 +4,6 @@ import java.nio.channels.AsynchronousSocketChannel; import java.util.List; import java.util.concurrent.CompletableFuture; - public class TwoPartyVatNetwork implements VatNetwork, VatNetwork.Connection { diff --git a/runtime/src/main/java/org/capnproto/VatNetwork.java b/runtime-rpc/src/main/java/org/capnproto/VatNetwork.java similarity index 100% rename from runtime/src/main/java/org/capnproto/VatNetwork.java rename to runtime-rpc/src/main/java/org/capnproto/VatNetwork.java diff --git a/runtime-rpc/src/main/schema/rpc-twoparty.capnp b/runtime-rpc/src/main/schema/rpc-twoparty.capnp new file mode 100644 index 0000000..1d54b47 --- /dev/null +++ b/runtime-rpc/src/main/schema/rpc-twoparty.capnp @@ -0,0 +1,173 @@ +# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors +# Licensed under the MIT License: +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +@0xa184c7885cdaf2a1; +# This file defines the "network-specific parameters" in rpc.capnp to support a network consisting +# of two vats. Each of these vats may in fact be in communication with other vats, but any +# capabilities they forward must be proxied. Thus, to each end of the connection, all capabilities +# received from the other end appear to live in a single vat. +# +# Two notable use cases for this model include: +# - Regular client-server communications, where a remote client machine (perhaps living on an end +# user's personal device) connects to a server. The server may be part of a cluster, and may +# call on other servers in the cluster to help service the user's request. It may even obtain +# capabilities from these other servers which it passes on to the user. To simplify network +# common traversal problems (e.g. if the user is behind a firewall), it is probably desirable to +# multiplex all communications between the server cluster and the client over the original +# connection rather than form new ones. This connection should use the two-party protocol, as +# the client has no interest in knowing about additional servers. +# - Applications running in a sandbox. A supervisor process may execute a confined application +# such that all of the confined app's communications with the outside world must pass through +# the supervisor. In this case, the connection between the confined app and the supervisor might +# as well use the two-party protocol, because the confined app is intentionally prevented from +# talking to any other vat anyway. Any external resources will be proxied through the supervisor, +# and so to the contained app will appear as if they were hosted by the supervisor itself. +# +# Since there are only two vats in this network, there is never a need for three-way introductions, +# so level 3 is free. Moreover, because it is never necessary to form new connections, the +# two-party protocol can be used easily anywhere where a two-way byte stream exists, without regard +# to where that byte stream goes or how it was initiated. This makes the two-party runtime library +# highly reusable. +# +# Joins (level 4) _could_ be needed in cases where one or both vats are participating in other +# networks that use joins. For instance, if Alice and Bob are speaking through the two-party +# protocol, and Bob is also participating on another network, Bob may send Alice two or more +# proxied capabilities which, unbeknownst to Bob at the time, are in fact pointing at the same +# remote object. Alice may then request to join these capabilities, at which point Bob will have +# to forward the join to the other network. Note, however, that if Alice is _not_ participating on +# any other network, then Alice will never need to _receive_ a Join, because Alice would always +# know when two locally-hosted capabilities are the same and would never export a redundant alias +# to Bob. So, Alice can respond to all incoming joins with an error, and only needs to implement +# outgoing joins if she herself desires to use this feature. Also, outgoing joins are relatively +# easy to implement in this scenario. +# +# What all this means is that a level 4 implementation of the confined network is barely more +# complicated than a level 2 implementation. However, such an implementation allows the "client" +# or "confined" app to access the server's/supervisor's network with equal functionality to any +# native participant. In other words, an application which implements only the two-party protocol +# can be paired with a proxy app in order to participate in any network. +# +# So, when implementing Cap'n Proto in a new language, it makes sense to implement only the +# two-party protocol initially, and then pair applications with an appropriate proxy written in +# C++, rather than implement other parameterizations of the RPC protocol directly. + +using Cxx = import "/capnp/c++.capnp"; +$Cxx.namespace("capnp::rpc::twoparty"); + +using Java = import "/capnp/java.capnp"; +$Java.package("org.capnproto"); +$Java.outerClassname("RpcTwoPartyProtocol"); + +# Note: SturdyRef is not specified here. It is up to the application to define semantics of +# SturdyRefs if desired. + +enum Side { + server @0; + # The object lives on the "server" or "supervisor" end of the connection. Only the + # server/supervisor knows how to interpret the ref; to the client, it is opaque. + # + # Note that containers intending to implement strong confinement should rewrite SturdyRefs + # received from the external network before passing them on to the confined app. The confined + # app thus does not ever receive the raw bits of the SturdyRef (which it could perhaps + # maliciously leak), but instead receives only a thing that it can pass back to the container + # later to restore the ref. See: + # http://www.erights.org/elib/capability/dist-confine.html + + client @1; + # The object lives on the "client" or "confined app" end of the connection. Only the client + # knows how to interpret the ref; to the server/supervisor, it is opaque. Most clients do not + # actually know how to persist capabilities at all, so use of this is unusual. +} + +struct VatId { + side @0 :Side; +} + +struct ProvisionId { + # Only used for joins, since three-way introductions never happen on a two-party network. + + joinId @0 :UInt32; + # The ID from `JoinKeyPart`. +} + +struct RecipientId {} +# Never used, because there are only two parties. + +struct ThirdPartyCapId {} +# Never used, because there is no third party. + +struct JoinKeyPart { + # Joins in the two-party case are simplified by a few observations. + # + # First, on a two-party network, a Join only ever makes sense if the receiving end is also + # connected to other networks. A vat which is not connected to any other network can safely + # reject all joins. + # + # Second, since a two-party connection bisects the network -- there can be no other connections + # between the networks at either end of the connection -- if one part of a join crosses the + # connection, then _all_ parts must cross it. Therefore, a vat which is receiving a Join request + # off some other network which needs to be forwarded across the two-party connection can + # collect all the parts on its end and only forward them across the two-party connection when all + # have been received. + # + # For example, imagine that Alice and Bob are vats connected over a two-party connection, and + # each is also connected to other networks. At some point, Alice receives one part of a Join + # request off her network. The request is addressed to a capability that Alice received from + # Bob and is proxying to her other network. Alice goes ahead and responds to the Join part as + # if she hosted the capability locally (this is important so that if not all the Join parts end + # up at Alice, the original sender can detect the failed Join without hanging). As other parts + # trickle in, Alice verifies that each part is addressed to a capability from Bob and continues + # to respond to each one. Once the complete set of join parts is received, Alice checks if they + # were all for the exact same capability. If so, she doesn't need to send anything to Bob at + # all. Otherwise, she collects the set of capabilities (from Bob) to which the join parts were + # addressed and essentially initiates a _new_ Join request on those capabilities to Bob. Alice + # does not forward the Join parts she received herself, but essentially forwards the Join as a + # whole. + # + # On Bob's end, since he knows that Alice will always send all parts of a Join together, he + # simply waits until he's received them all, then performs a join on the respective capabilities + # as if it had been requested locally. + + joinId @0 :UInt32; + # A number identifying this join, chosen by the sender. May be reused once `Finish` messages are + # sent corresponding to all of the `Join` messages. + + partCount @1 :UInt16; + # The number of capabilities to be joined. + + partNum @2 :UInt16; + # Which part this request targets -- a number in the range [0, partCount). +} + +struct JoinResult { + joinId @0 :UInt32; + # Matches `JoinKeyPart`. + + succeeded @1 :Bool; + # All JoinResults in the set will have the same value for `succeeded`. The receiver actually + # implements the join by waiting for all the `JoinKeyParts` and then performing its own join on + # them, then going back and answering all the join requests afterwards. + + cap @2 :AnyPointer; + # One of the JoinResults will have a non-null `cap` which is the joined capability. + # + # TODO(cleanup): Change `AnyPointer` to `Capability` when that is supported. +} diff --git a/runtime-rpc/src/main/schema/rpc.capnp b/runtime-rpc/src/main/schema/rpc.capnp new file mode 100644 index 0000000..9a406dd --- /dev/null +++ b/runtime-rpc/src/main/schema/rpc.capnp @@ -0,0 +1,1480 @@ +# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors +# Licensed under the MIT License: +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +@0xb312981b2552a250; +# Recall that Cap'n Proto RPC allows messages to contain references to remote objects that +# implement interfaces. These references are called "capabilities", because they both designate +# the remote object to use and confer permission to use it. +# +# Recall also that Cap'n Proto RPC has the feature that when a method call itself returns a +# capability, the caller can begin calling methods on that capability _before the first call has +# returned_. The caller essentially sends a message saying "Hey server, as soon as you finish +# that previous call, do this with the result!". Cap'n Proto's RPC protocol makes this possible. +# +# The protocol is significantly more complicated than most RPC protocols. However, this is +# implementation complexity that underlies an easy-to-grasp higher-level model of object oriented +# programming. That is, just like TCP is a surprisingly complicated protocol that implements a +# conceptually-simple byte stream abstraction, Cap'n Proto is a surprisingly complicated protocol +# that implements a conceptually-simple object abstraction. +# +# Cap'n Proto RPC is based heavily on CapTP, the object-capability protocol used by the E +# programming language: +# http://www.erights.org/elib/distrib/captp/index.html +# +# Cap'n Proto RPC takes place between "vats". A vat hosts some set of objects and talks to other +# vats through direct bilateral connections. Typically, there is a 1:1 correspondence between vats +# and processes (in the unix sense of the word), although this is not strictly always true (one +# process could run multiple vats, or a distributed virtual vat might live across many processes). +# +# Cap'n Proto does not distinguish between "clients" and "servers" -- this is up to the application. +# Either end of any connection can potentially hold capabilities pointing to the other end, and +# can call methods on those capabilities. In the doc comments below, we use the words "sender" +# and "receiver". These refer to the sender and receiver of an instance of the struct or field +# being documented. Sometimes we refer to a "third-party" that is neither the sender nor the +# receiver. Documentation is generally written from the point of view of the sender. +# +# It is generally up to the vat network implementation to securely verify that connections are made +# to the intended vat as well as to encrypt transmitted data for privacy and integrity. See the +# `VatNetwork` example interface near the end of this file. +# +# When a new connection is formed, the only interesting things that can be done are to send a +# `Bootstrap` (level 0) or `Accept` (level 3) message. +# +# Unless otherwise specified, messages must be delivered to the receiving application in the same +# order in which they were initiated by the sending application. The goal is to support "E-Order", +# which states that two calls made on the same reference must be delivered in the order which they +# were made: +# http://erights.org/elib/concurrency/partial-order.html +# +# Since the full protocol is complicated, we define multiple levels of support that an +# implementation may target. For many applications, level 1 support will be sufficient. +# Comments in this file indicate which level requires the corresponding feature to be +# implemented. +# +# * **Level 0:** The implementation does not support object references. Only the bootstrap interface +# can be called. At this level, the implementation does not support object-oriented protocols and +# is similar in complexity to JSON-RPC or Protobuf services. This level should be considered only +# a temporary stepping-stone toward level 1 as the lack of object references drastically changes +# how protocols are designed. Applications _should not_ attempt to design their protocols around +# the limitations of level 0 implementations. +# +# * **Level 1:** The implementation supports simple bilateral interaction with object references +# and promise pipelining, but interactions between three or more parties are supported only via +# proxying of objects. E.g. if Alice (in Vat A) wants to send Bob (in Vat B) a capability +# pointing to Carol (in Vat C), Alice must create a proxy of Carol within Vat A and send Bob a +# reference to that; Bob cannot form a direct connection to Carol. Level 1 implementations do +# not support checking if two capabilities received from different vats actually point to the +# same object ("join"), although they should be able to do this check on capabilities received +# from the same vat. +# +# * **Level 2:** The implementation supports saving persistent capabilities -- i.e. capabilities +# that remain valid even after disconnect, and can be restored on a future connection. When a +# capability is saved, the requester receives a `SturdyRef`, which is a token that can be used +# to restore the capability later. +# +# * **Level 3:** The implementation supports three-way interactions. That is, if Alice (in Vat A) +# sends Bob (in Vat B) a capability pointing to Carol (in Vat C), then Vat B will automatically +# form a direct connection to Vat C rather than have requests be proxied through Vat A. +# +# * **Level 4:** The entire protocol is implemented, including joins (checking if two capabilities +# are equivalent). +# +# Note that an implementation must also support specific networks (transports), as described in +# the "Network-specific Parameters" section below. An implementation might have different levels +# depending on the network used. +# +# New implementations of Cap'n Proto should start out targeting the simplistic two-party network +# type as defined in `rpc-twoparty.capnp`. With this network type, level 3 is irrelevant and +# levels 2 and 4 are much easier than usual to implement. When such an implementation is paired +# with a container proxy, the contained app effectively gets to make full use of the proxy's +# network at level 4. And since Cap'n Proto IPC is extremely fast, it may never make sense to +# bother implementing any other vat network protocol -- just use the correct container type and get +# it for free. + +using Cxx = import "/capnp/c++.capnp"; +$Cxx.namespace("capnp::rpc"); + +using Java = import "/capnp/java.capnp"; +$Java.package("org.capnproto"); +$Java.outerClassname("RpcProtocol"); + +# ======================================================================================== +# The Four Tables +# +# Cap'n Proto RPC connections are stateful (although an application built on Cap'n Proto could +# export a stateless interface). As in CapTP, for each open connection, a vat maintains four state +# tables: questions, answers, imports, and exports. See the diagram at: +# http://www.erights.org/elib/distrib/captp/4tables.html +# +# The question table corresponds to the other end's answer table, and the imports table corresponds +# to the other end's exports table. +# +# The entries in each table are identified by ID numbers (defined below as 32-bit integers). These +# numbers are always specific to the connection; a newly-established connection starts with no +# valid IDs. Since low-numbered IDs will pack better, it is suggested that IDs be assigned like +# Unix file descriptors -- prefer the lowest-number ID that is currently available. +# +# IDs in the questions/answers tables are chosen by the questioner and generally represent method +# calls that are in progress. +# +# IDs in the imports/exports tables are chosen by the exporter and generally represent objects on +# which methods may be called. Exports may be "settled", meaning the exported object is an actual +# object living in the exporter's vat, or they may be "promises", meaning the exported object is +# the as-yet-unknown result of an ongoing operation and will eventually be resolved to some other +# object once that operation completes. Calls made to a promise will be forwarded to the eventual +# target once it is known. The eventual replacement object does *not* get the same ID as the +# promise, as it may turn out to be an object that is already exported (so already has an ID) or +# may even live in a completely different vat (and so won't get an ID on the same export table +# at all). +# +# IDs can be reused over time. To make this safe, we carefully define the lifetime of IDs. Since +# messages using the ID could be traveling in both directions simultaneously, we must define the +# end of life of each ID _in each direction_. The ID is only safe to reuse once it has been +# released by both sides. +# +# When a Cap'n Proto connection is lost, everything on the four tables is lost. All questions are +# canceled and throw exceptions. All imports become broken (all future calls to them throw +# exceptions). All exports and answers are implicitly released. The only things not lost are +# persistent capabilities (`SturdyRef`s). The application must plan for this and should respond by +# establishing a new connection and restoring from these persistent capabilities. + +using QuestionId = UInt32; +# **(level 0)** +# +# Identifies a question in the sender's question table (which corresponds to the receiver's answer +# table). The questioner (caller) chooses an ID when making a call. The ID remains valid in +# caller -> callee messages until a Finish message is sent, and remains valid in callee -> caller +# messages until a Return message is sent. + +using AnswerId = QuestionId; +# **(level 0)** +# +# Identifies an answer in the sender's answer table (which corresponds to the receiver's question +# table). +# +# AnswerId is physically equivalent to QuestionId, since the question and answer tables correspond, +# but we define a separate type for documentation purposes: we always use the type representing +# the sender's point of view. + +using ExportId = UInt32; +# **(level 1)** +# +# Identifies an exported capability or promise in the sender's export table (which corresponds +# to the receiver's import table). The exporter chooses an ID before sending a capability over the +# wire. If the capability is already in the table, the exporter should reuse the same ID. If the +# ID is a promise (as opposed to a settled capability), this must be indicated at the time the ID +# is introduced (e.g. by using `senderPromise` instead of `senderHosted` in `CapDescriptor`); in +# this case, the importer shall expect a later `Resolve` message that replaces the promise. +# +# ExportId/ImportIds are subject to reference counting. Whenever an `ExportId` is sent over the +# wire (from the exporter to the importer), the export's reference count is incremented (unless +# otherwise specified). The reference count is later decremented by a `Release` message. Since +# the `Release` message can specify an arbitrary number by which to reduce the reference count, the +# importer should usually batch reference decrements and only send a `Release` when it believes the +# reference count has hit zero. Of course, it is possible that a new reference to the export is +# in-flight at the time that the `Release` message is sent, so it is necessary for the exporter to +# keep track of the reference count on its end as well to avoid race conditions. +# +# When a connection is lost, all exports are implicitly released. It is not possible to restore +# a connection state after disconnect (although a transport layer could implement a concept of +# persistent connections if it is transparent to the RPC layer). + +using ImportId = ExportId; +# **(level 1)** +# +# Identifies an imported capability or promise in the sender's import table (which corresponds to +# the receiver's export table). +# +# ImportId is physically equivalent to ExportId, since the export and import tables correspond, +# but we define a separate type for documentation purposes: we always use the type representing +# the sender's point of view. +# +# An `ImportId` remains valid in importer -> exporter messages until the importer has sent +# `Release` messages that (it believes) have reduced the reference count to zero. + +# ======================================================================================== +# Messages + +struct Message { + # An RPC connection is a bi-directional stream of Messages. + + union { + unimplemented @0 :Message; + # The sender previously received this message from the peer but didn't understand it or doesn't + # yet implement the functionality that was requested. So, the sender is echoing the message + # back. In some cases, the receiver may be able to recover from this by pretending the sender + # had taken some appropriate "null" action. + # + # For example, say `resolve` is received by a level 0 implementation (because a previous call + # or return happened to contain a promise). The level 0 implementation will echo it back as + # `unimplemented`. The original sender can then simply release the cap to which the promise + # had resolved, thus avoiding a leak. + # + # For any message type that introduces a question, if the message comes back unimplemented, + # the original sender may simply treat it as if the question failed with an exception. + # + # In cases where there is no sensible way to react to an `unimplemented` message (without + # resource leaks or other serious problems), the connection may need to be aborted. This is + # a gray area; different implementations may take different approaches. + + abort @1 :Exception; + # Sent when a connection is being aborted due to an unrecoverable error. This could be e.g. + # because the sender received an invalid or nonsensical message or because the sender had an + # internal error. The sender will shut down the outgoing half of the connection after `abort` + # and will completely close the connection shortly thereafter (it's up to the sender how much + # of a time buffer they want to offer for the client to receive the `abort` before the + # connection is reset). + + # Level 0 features ----------------------------------------------- + + bootstrap @8 :Bootstrap; # Request the peer's bootstrap interface. + call @2 :Call; # Begin a method call. + return @3 :Return; # Complete a method call. + finish @4 :Finish; # Release a returned answer / cancel a call. + + # Level 1 features ----------------------------------------------- + + resolve @5 :Resolve; # Resolve a previously-sent promise. + release @6 :Release; # Release a capability so that the remote object can be deallocated. + disembargo @13 :Disembargo; # Lift an embargo used to enforce E-order over promise resolution. + + # Level 2 features ----------------------------------------------- + + obsoleteSave @7 :AnyPointer; + # Obsolete request to save a capability, resulting in a SturdyRef. This has been replaced + # by the `Persistent` interface defined in `persistent.capnp`. This operation was never + # implemented. + + obsoleteDelete @9 :AnyPointer; + # Obsolete way to delete a SturdyRef. This operation was never implemented. + + # Level 3 features ----------------------------------------------- + + provide @10 :Provide; # Provide a capability to a third party. + accept @11 :Accept; # Accept a capability provided by a third party. + + # Level 4 features ----------------------------------------------- + + join @12 :Join; # Directly connect to the common root of two or more proxied caps. + } +} + +# Level 0 message types ---------------------------------------------- + +struct Bootstrap { + # **(level 0)** + # + # Get the "bootstrap" interface exported by the remote vat. + # + # For level 0, 1, and 2 implementations, the "bootstrap" interface is simply the main interface + # exported by a vat. If the vat acts as a server fielding connections from clients, then the + # bootstrap interface defines the basic functionality available to a client when it connects. + # The exact interface definition obviously depends on the application. + # + # We call this a "bootstrap" because in an ideal Cap'n Proto world, bootstrap interfaces would + # never be used. In such a world, any time you connect to a new vat, you do so because you + # received an introduction from some other vat (see `ThirdPartyCapId`). Thus, the first message + # you send is `Accept`, and further communications derive from there. `Bootstrap` is not used. + # + # In such an ideal world, DNS itself would support Cap'n Proto -- performing a DNS lookup would + # actually return a new Cap'n Proto capability, thus introducing you to the target system via + # level 3 RPC. Applications would receive the capability to talk to DNS in the first place as + # an initial endowment or part of a Powerbox interaction. Therefore, an app can form arbitrary + # connections without ever using `Bootstrap`. + # + # Of course, in the real world, DNS is not Cap'n-Proto-based, and we don't want Cap'n Proto to + # require a whole new internet infrastructure to be useful. Therefore, we offer bootstrap + # interfaces as a way to get up and running without a level 3 introduction. Thus, bootstrap + # interfaces are used to "bootstrap" from other, non-Cap'n-Proto-based means of service discovery, + # such as legacy DNS. + # + # Note that a vat need not provide a bootstrap interface, and in fact many vats (especially those + # acting as clients) do not. In this case, the vat should either reply to `Bootstrap` with a + # `Return` indicating an exception, or should return a dummy capability with no methods. + + questionId @0 :QuestionId; + # A new question ID identifying this request, which will eventually receive a Return message + # containing the restored capability. + + deprecatedObjectId @1 :AnyPointer; + # ** DEPRECATED ** + # + # A Vat may export multiple bootstrap interfaces. In this case, `deprecatedObjectId` specifies + # which one to return. If this pointer is null, then the default bootstrap interface is returned. + # + # As of verison 0.5, use of this field is deprecated. If a service wants to export multiple + # bootstrap interfaces, it should instead define a single bootstrap interface that has methods + # that return each of the other interfaces. + # + # **History** + # + # In the first version of Cap'n Proto RPC (0.4.x) the `Bootstrap` message was called `Restore`. + # At the time, it was thought that this would eventually serve as the way to restore SturdyRefs + # (level 2). Meanwhile, an application could offer its "main" interface on a well-known + # (non-secret) SturdyRef. + # + # Since level 2 RPC was not implemented at the time, the `Restore` message was in practice only + # used to obtain the main interface. Since most applications had only one main interface that + # they wanted to restore, they tended to designate this with a null `objectId`. + # + # Unfortunately, the earliest version of the EZ RPC interfaces set a precedent of exporting + # multiple main interfaces by allowing them to be exported under string names. In this case, + # `objectId` was a Text value specifying the name. + # + # All of this proved problematic for several reasons: + # + # - The arrangement assumed that a client wishing to restore a SturdyRef would know exactly what + # machine to connect to and would be able to immediately restore a SturdyRef on connection. + # However, in practice, the ability to restore SturdyRefs is itself a capability that may + # require going through an authentication process to obtain. Thus, it makes more sense to + # define a "restorer service" as a full Cap'n Proto interface. If this restorer interface is + # offered as the vat's bootstrap interface, then this is equivalent to the old arrangement. + # + # - Overloading "Restore" for the purpose of obtaining well-known capabilities encouraged the + # practice of exporting singleton services with string names. If singleton services are desired, + # it is better to have one main interface that has methods that can be used to obtain each + # service, in order to get all the usual benefits of schemas and type checking. + # + # - Overloading "Restore" also had a security problem: Often, "main" or "well-known" + # capabilities exported by a vat are in fact not public: they are intended to be accessed only + # by clients who are capable of forming a connection to the vat. This can lead to trouble if + # the client itself has other clients and wishes to foward some `Restore` requests from those + # external clients -- it has to be very careful not to allow through `Restore` requests + # addressing the default capability. + # + # For example, consider the case of a sandboxed Sandstorm application and its supervisor. The + # application exports a default capability to its supervisor that provides access to + # functionality that only the supervisor is supposed to access. Meanwhile, though, applications + # may publish other capabilities that may be persistent, in which case the application needs + # to field `Restore` requests that could come from anywhere. These requests of course have to + # pass through the supervisor, as all communications with the outside world must. But, the + # supervisor has to be careful not to honor an external request addressing the application's + # default capability, since this capability is privileged. Unfortunately, the default + # capability cannot be given an unguessable name, because then the supervisor itself would not + # be able to address it! + # + # As of Cap'n Proto 0.5, `Restore` has been renamed to `Bootstrap` and is no longer planned for + # use in restoring SturdyRefs. + # + # Note that 0.4 also defined a message type called `Delete` that, like `Restore`, addressed a + # SturdyRef, but indicated that the client would not restore the ref again in the future. This + # operation was never implemented, so it was removed entirely. If a "delete" operation is desired, + # it should exist as a method on the same interface that handles restoring SturdyRefs. However, + # the utility of such an operation is questionable. You wouldn't be able to rely on it for + # garbage collection since a client could always disappear permanently without remembering to + # delete all its SturdyRefs, thus leaving them dangling forever. Therefore, it is advisable to + # design systems such that SturdyRefs never represent "owned" pointers. + # + # For example, say a SturdyRef points to an image file hosted on some server. That image file + # should also live inside a collection (a gallery, perhaps) hosted on the same server, owned by + # a user who can delete the image at any time. If the user deletes the image, the SturdyRef + # stops working. On the other hand, if the SturdyRef is discarded, this has no effect on the + # existence of the image in its collection. +} + +struct Call { + # **(level 0)** + # + # Message type initiating a method call on a capability. + + questionId @0 :QuestionId; + # A number, chosen by the caller, that identifies this call in future messages. This number + # must be different from all other calls originating from the same end of the connection (but + # may overlap with question IDs originating from the opposite end). A fine strategy is to use + # sequential question IDs, but the recipient should not assume this. + # + # A question ID can be reused once both: + # - A matching Return has been received from the callee. + # - A matching Finish has been sent from the caller. + + target @1 :MessageTarget; + # The object that should receive this call. + + interfaceId @2 :UInt64; + # The type ID of the interface being called. Each capability may implement multiple interfaces. + + methodId @3 :UInt16; + # The ordinal number of the method to call within the requested interface. + + allowThirdPartyTailCall @8 :Bool = false; + # Indicates whether or not the receiver is allowed to send a `Return` containing + # `acceptFromThirdParty`. Level 3 implementations should set this true. Otherwise, the callee + # will have to proxy the return in the case of a tail call to a third-party vat. + + params @4 :Payload; + # The call parameters. `params.content` is a struct whose fields correspond to the parameters of + # the method. + + sendResultsTo :union { + # Where should the return message be sent? + + caller @5 :Void; + # Send the return message back to the caller (the usual). + + yourself @6 :Void; + # **(level 1)** + # + # Don't actually return the results to the sender. Instead, hold on to them and await + # instructions from the sender regarding what to do with them. In particular, the sender + # may subsequently send a `Return` for some other call (which the receiver had previously made + # to the sender) with `takeFromOtherQuestion` set. The results from this call are then used + # as the results of the other call. + # + # When `yourself` is used, the receiver must still send a `Return` for the call, but sets the + # field `resultsSentElsewhere` in that `Return` rather than including the results. + # + # This feature can be used to implement tail calls in which a call from Vat A to Vat B ends up + # returning the result of a call from Vat B back to Vat A. + # + # In particular, the most common use case for this feature is when Vat A makes a call to a + # promise in Vat B, and then that promise ends up resolving to a capability back in Vat A. + # Vat B must forward all the queued calls on that promise back to Vat A, but can set `yourself` + # in the calls so that the results need not pass back through Vat B. + # + # For example: + # - Alice, in Vat A, calls foo() on Bob in Vat B. + # - Alice makes a pipelined call bar() on the promise returned by foo(). + # - Later on, Bob resolves the promise from foo() to point at Carol, who lives in Vat A (next + # to Alice). + # - Vat B dutifully forwards the bar() call to Carol. Let us call this forwarded call bar'(). + # Notice that bar() and bar'() are travelling in opposite directions on the same network + # link. + # - The `Call` for bar'() has `sendResultsTo` set to `yourself`. + # - Vat B sends a `Return` for bar() with `takeFromOtherQuestion` set in place of the results, + # with the value set to the question ID of bar'(). Vat B does not wait for bar'() to return, + # as doing so would introduce unnecessary round trip latency. + # - Vat A receives bar'() and delivers it to Carol. + # - When bar'() returns, Vat A sends a `Return` for bar'() to Vat B, with `resultsSentElsewhere` + # set in place of results. + # - Vat A sends a `Finish` for the bar() call to Vat B. + # - Vat B receives the `Finish` for bar() and sends a `Finish` for bar'(). + + thirdParty @7 :RecipientId; + # **(level 3)** + # + # The call's result should be returned to a different vat. The receiver (the callee) expects + # to receive an `Accept` message from the indicated vat, and should return the call's result + # to it, rather than to the sender of the `Call`. + # + # This operates much like `yourself`, above, except that Carol is in a separate Vat C. `Call` + # messages are sent from Vat A -> Vat B and Vat B -> Vat C. A `Return` message is sent from + # Vat B -> Vat A that contains `acceptFromThirdParty` in place of results. When Vat A sends + # an `Accept` to Vat C, it receives back a `Return` containing the call's actual result. Vat C + # also sends a `Return` to Vat B with `resultsSentElsewhere`. + } +} + +struct Return { + # **(level 0)** + # + # Message type sent from callee to caller indicating that the call has completed. + + answerId @0 :AnswerId; + # Equal to the QuestionId of the corresponding `Call` message. + + releaseParamCaps @1 :Bool = true; + # If true, all capabilities that were in the params should be considered released. The sender + # must not send separate `Release` messages for them. Level 0 implementations in particular + # should always set this true. This defaults true because if level 0 implementations forget to + # set it they'll never notice (just silently leak caps), but if level >=1 implementations forget + # to set it to false they'll quickly get errors. + # + # The receiver should act as if the sender had sent a release message with count=1 for each + # CapDescriptor in the original Call message. + + union { + results @2 :Payload; + # The result. + # + # For regular method calls, `results.content` points to the result struct. + # + # For a `Return` in response to an `Accept` or `Bootstrap`, `results` contains a single + # capability (rather than a struct), and `results.content` is just a capability pointer with + # index 0. A `Finish` is still required in this case. + + exception @3 :Exception; + # Indicates that the call failed and explains why. + + canceled @4 :Void; + # Indicates that the call was canceled due to the caller sending a Finish message + # before the call had completed. + + resultsSentElsewhere @5 :Void; + # This is set when returning from a `Call` that had `sendResultsTo` set to something other + # than `caller`. + # + # It doesn't matter too much when this is sent, as the receiver doesn't need to do anything + # with it, but the C++ implementation appears to wait for the call to finish before sending + # this. + + takeFromOtherQuestion @6 :QuestionId; + # The sender has also sent (before this message) a `Call` with the given question ID and with + # `sendResultsTo.yourself` set, and the results of that other call should be used as the + # results here. `takeFromOtherQuestion` can only used once per question. + + acceptFromThirdParty @7 :ThirdPartyCapId; + # **(level 3)** + # + # The caller should contact a third-party vat to pick up the results. An `Accept` message + # sent to the vat will return the result. This pairs with `Call.sendResultsTo.thirdParty`. + # It should only be used if the corresponding `Call` had `allowThirdPartyTailCall` set. + } +} + +struct Finish { + # **(level 0)** + # + # Message type sent from the caller to the callee to indicate: + # 1) The questionId will no longer be used in any messages sent by the callee (no further + # pipelined requests). + # 2) If the call has not returned yet, the caller no longer cares about the result. If nothing + # else cares about the result either (e.g. there are no other outstanding calls pipelined on + # the result of this one) then the callee may wish to immediately cancel the operation and + # send back a Return message with "canceled" set. However, implementations are not required + # to support premature cancellation -- instead, the implementation may wait until the call + # actually completes and send a normal `Return` message. + # + # TODO(someday): Should we separate (1) and implicitly releasing result capabilities? It would be + # possible and useful to notify the server that it doesn't need to keep around the response to + # service pipeline requests even though the caller still wants to receive it / hasn't yet + # finished processing it. It could also be useful to notify the server that it need not marshal + # the results because the caller doesn't want them anyway, even if the caller is still sending + # pipelined calls, although this seems less useful (just saving some bytes on the wire). + + questionId @0 :QuestionId; + # ID of the call whose result is to be released. + + releaseResultCaps @1 :Bool = true; + # If true, all capabilities that were in the results should be considered released. The sender + # must not send separate `Release` messages for them. Level 0 implementations in particular + # should always set this true. This defaults true because if level 0 implementations forget to + # set it they'll never notice (just silently leak caps), but if level >=1 implementations forget + # set it false they'll quickly get errors. +} + +# Level 1 message types ---------------------------------------------- + +struct Resolve { + # **(level 1)** + # + # Message type sent to indicate that a previously-sent promise has now been resolved to some other + # object (possibly another promise) -- or broken, or canceled. + # + # Keep in mind that it's possible for a `Resolve` to be sent to a level 0 implementation that + # doesn't implement it. For example, a method call or return might contain a capability in the + # payload. Normally this is fine even if the receiver is level 0, because they will implicitly + # release all such capabilities on return / finish. But if the cap happens to be a promise, then + # a follow-up `Resolve` may be sent regardless of this release. The level 0 receiver will reply + # with an `unimplemented` message, and the sender (of the `Resolve`) can respond to this as if the + # receiver had immediately released any capability to which the promise resolved. + # + # When implementing promise resolution, it's important to understand how embargos work and the + # tricky case of the Tribble 4-way race condition. See the comments for the Disembargo message, + # below. + + promiseId @0 :ExportId; + # The ID of the promise to be resolved. + # + # Unlike all other instances of `ExportId` sent from the exporter, the `Resolve` message does + # _not_ increase the reference count of `promiseId`. In fact, it is expected that the receiver + # will release the export soon after receiving `Resolve`, and the sender will not send this + # `ExportId` again until it has been released and recycled. + # + # When an export ID sent over the wire (e.g. in a `CapDescriptor`) is indicated to be a promise, + # this indicates that the sender will follow up at some point with a `Resolve` message. If the + # same `promiseId` is sent again before `Resolve`, still only one `Resolve` is sent. If the + # same ID is sent again later _after_ a `Resolve`, it can only be because the export's + # reference count hit zero in the meantime and the ID was re-assigned to a new export, therefore + # this later promise does _not_ correspond to the earlier `Resolve`. + # + # If a promise ID's reference count reaches zero before a `Resolve` is sent, the `Resolve` + # message may or may not still be sent (the `Resolve` may have already been in-flight when + # `Release` was sent, but if the `Release` is received before `Resolve` then there is no longer + # any reason to send a `Resolve`). Thus a `Resolve` may be received for a promise of which + # the receiver has no knowledge, because it already released it earlier. In this case, the + # receiver should simply release the capability to which the promise resolved. + + union { + cap @1 :CapDescriptor; + # The object to which the promise resolved. + # + # The sender promises that from this point forth, until `promiseId` is released, it shall + # simply forward all messages to the capability designated by `cap`. This is true even if + # `cap` itself happens to designate another promise, and that other promise later resolves -- + # messages sent to `promiseId` shall still go to that other promise, not to its resolution. + # This is important in the case that the receiver of the `Resolve` ends up sending a + # `Disembargo` message towards `promiseId` in order to control message ordering -- that + # `Disembargo` really needs to reflect back to exactly the object designated by `cap` even + # if that object is itself a promise. + + exception @2 :Exception; + # Indicates that the promise was broken. + } +} + +struct Release { + # **(level 1)** + # + # Message type sent to indicate that the sender is done with the given capability and the receiver + # can free resources allocated to it. + + id @0 :ImportId; + # What to release. + + referenceCount @1 :UInt32; + # The amount by which to decrement the reference count. The export is only actually released + # when the reference count reaches zero. +} + +struct Disembargo { + # **(level 1)** + # + # Message sent to indicate that an embargo on a recently-resolved promise may now be lifted. + # + # Embargos are used to enforce E-order in the presence of promise resolution. That is, if an + # application makes two calls foo() and bar() on the same capability reference, in that order, + # the calls should be delivered in the order in which they were made. But if foo() is called + # on a promise, and that promise happens to resolve before bar() is called, then the two calls + # may travel different paths over the network, and thus could arrive in the wrong order. In + # this case, the call to `bar()` must be embargoed, and a `Disembargo` message must be sent along + # the same path as `foo()` to ensure that the `Disembargo` arrives after `foo()`. Once the + # `Disembargo` arrives, `bar()` can then be delivered. + # + # There are two particular cases where embargos are important. Consider object Alice, in Vat A, + # who holds a promise P, pointing towards Vat B, that eventually resolves to Carol. The two + # cases are: + # - Carol lives in Vat A, i.e. next to Alice. In this case, Vat A needs to send a `Disembargo` + # message that echos through Vat B and back, to ensure that all pipelined calls on the promise + # have been delivered. + # - Carol lives in a different Vat C. When the promise resolves, a three-party handoff occurs + # (see `Provide` and `Accept`, which constitute level 3 of the protocol). In this case, we + # piggyback on the state that has already been set up to handle the handoff: the `Accept` + # message (from Vat A to Vat C) is embargoed, as are all pipelined messages sent to it, while + # a `Disembargo` message is sent from Vat A through Vat B to Vat C. See `Accept.embargo` for + # an example. + # + # Note that in the case where Carol actually lives in Vat B (i.e., the same vat that the promise + # already pointed at), no embargo is needed, because the pipelined calls are delivered over the + # same path as the later direct calls. + # + # Keep in mind that promise resolution happens both in the form of Resolve messages as well as + # Return messages (which resolve PromisedAnswers). Embargos apply in both cases. + # + # An alternative strategy for enforcing E-order over promise resolution could be for Vat A to + # implement the embargo internally. When Vat A is notified of promise resolution, it could + # send a dummy no-op call to promise P and wait for it to complete. Until that call completes, + # all calls to the capability are queued locally. This strategy works, but is pessimistic: + # in the three-party case, it requires an A -> B -> C -> B -> A round trip before calls can start + # being delivered directly to from Vat A to Vat C. The `Disembargo` message allows latency to be + # reduced. (In the two-party loopback case, the `Disembargo` message is just a more explicit way + # of accomplishing the same thing as a no-op call, but isn't any faster.) + # + # *The Tribble 4-way Race Condition* + # + # Any implementation of promise resolution and embargos must be aware of what we call the + # "Tribble 4-way race condition", after Dean Tribble, who explained the problem in a lively + # Friam meeting. + # + # Embargos are designed to work in the case where a two-hop path is being shortened to one hop. + # But sometimes there are more hops. Imagine that Alice has a reference to a remote promise P1 + # that eventually resolves to _another_ remote promise P2 (in a third vat), which _at the same + # time_ happens to resolve to Bob (in a fourth vat). In this case, we're shortening from a 3-hop + # path (with four parties) to a 1-hop path (Alice -> Bob). + # + # Extending the embargo/disembargo protocol to be able to shorted multiple hops at once seems + # difficult. Instead, we make a rule that prevents this case from coming up: + # + # One a promise P has been resolved to a remote object reference R, then all further messages + # received addressed to P will be forwarded strictly to R. Even if it turns out later that R is + # itself a promise, and has resolved to some other object Q, messages sent to P will still be + # forwarded to R, not directly to Q (R will of course further forward the messages to Q). + # + # This rule does not cause a significant performance burden because once P has resolved to R, it + # is expected that people sending messages to P will shortly start sending them to R instead and + # drop P. P is at end-of-life anyway, so it doesn't matter if it ignores chances to further + # optimize its path. + + target @0 :MessageTarget; + # What is to be disembargoed. + + using EmbargoId = UInt32; + # Used in `senderLoopback` and `receiverLoopback`, below. + + context :union { + senderLoopback @1 :EmbargoId; + # The sender is requesting a disembargo on a promise that is known to resolve back to a + # capability hosted by the sender. As soon as the receiver has echoed back all pipelined calls + # on this promise, it will deliver the Disembargo back to the sender with `receiverLoopback` + # set to the same value as `senderLoopback`. This value is chosen by the sender, and since + # it is also consumed be the sender, the sender can use whatever strategy it wants to make sure + # the value is unambiguous. + # + # The receiver must verify that the target capability actually resolves back to the sender's + # vat. Otherwise, the sender has committed a protocol error and should be disconnected. + + receiverLoopback @2 :EmbargoId; + # The receiver previously sent a `senderLoopback` Disembargo towards a promise resolving to + # this capability, and that Disembargo is now being echoed back. + + accept @3 :Void; + # **(level 3)** + # + # The sender is requesting a disembargo on a promise that is known to resolve to a third-party + # capability that the sender is currently in the process of accepting (using `Accept`). + # The receiver of this `Disembargo` has an outstanding `Provide` on said capability. The + # receiver should now send a `Disembargo` with `provide` set to the question ID of that + # `Provide` message. + # + # See `Accept.embargo` for an example. + + provide @4 :QuestionId; + # **(level 3)** + # + # The sender is requesting a disembargo on a capability currently being provided to a third + # party. The question ID identifies the `Provide` message previously sent by the sender to + # this capability. On receipt, the receiver (the capability host) shall release the embargo + # on the `Accept` message that it has received from the third party. See `Accept.embargo` for + # an example. + } +} + +# Level 2 message types ---------------------------------------------- + +# See persistent.capnp. + +# Level 3 message types ---------------------------------------------- + +struct Provide { + # **(level 3)** + # + # Message type sent to indicate that the sender wishes to make a particular capability implemented + # by the receiver available to a third party for direct access (without the need for the third + # party to proxy through the sender). + # + # (In CapTP, `Provide` and `Accept` are methods of the global `NonceLocator` object exported by + # every vat. In Cap'n Proto, we bake this into the core protocol.) + + questionId @0 :QuestionId; + # Question ID to be held open until the recipient has received the capability. A result will be + # returned once the third party has successfully received the capability. The sender must at some + # point send a `Finish` message as with any other call, and that message can be used to cancel the + # whole operation. + + target @1 :MessageTarget; + # What is to be provided to the third party. + + recipient @2 :RecipientId; + # Identity of the third party that is expected to pick up the capability. +} + +struct Accept { + # **(level 3)** + # + # Message type sent to pick up a capability hosted by the receiving vat and provided by a third + # party. The third party previously designated the capability using `Provide`. + # + # This message is also used to pick up a redirected return -- see `Return.acceptFromThirdParty`. + + questionId @0 :QuestionId; + # A new question ID identifying this accept message, which will eventually receive a Return + # message containing the provided capability (or the call result in the case of a redirected + # return). + + provision @1 :ProvisionId; + # Identifies the provided object to be picked up. + + embargo @2 :Bool; + # If true, this accept shall be temporarily embargoed. The resulting `Return` will not be sent, + # and any pipelined calls will not be delivered, until the embargo is released. The receiver + # (the capability host) will expect the provider (the vat that sent the `Provide` message) to + # eventually send a `Disembargo` message with the field `context.provide` set to the question ID + # of the original `Provide` message. At that point, the embargo is released and the queued + # messages are delivered. + # + # For example: + # - Alice, in Vat A, holds a promise P, which currently points toward Vat B. + # - Alice calls foo() on P. The `Call` message is sent to Vat B. + # - The promise P in Vat B ends up resolving to Carol, in Vat C. + # - Vat B sends a `Provide` message to Vat C, identifying Vat A as the recipient. + # - Vat B sends a `Resolve` message to Vat A, indicating that the promise has resolved to a + # `ThirdPartyCapId` identifying Carol in Vat C. + # - Vat A sends an `Accept` message to Vat C to pick up the capability. Since Vat A knows that + # it has an outstanding call to the promise, it sets `embargo` to `true` in the `Accept` + # message. + # - Vat A sends a `Disembargo` message to Vat B on promise P, with `context.accept` set. + # - Alice makes a call bar() to promise P, which is now pointing towards Vat C. Alice doesn't + # know anything about the mechanics of promise resolution happening under the hood, but she + # expects that bar() will be delivered after foo() because that is the order in which she + # initiated the calls. + # - Vat A sends the bar() call to Vat C, as a pipelined call on the result of the `Accept` (which + # hasn't returned yet, due to the embargo). Since calls to the newly-accepted capability + # are embargoed, Vat C does not deliver the call yet. + # - At some point, Vat B forwards the foo() call from the beginning of this example on to Vat C. + # - Vat B forwards the `Disembargo` from Vat A on to vat C. It sets `context.provide` to the + # question ID of the `Provide` message it had sent previously. + # - Vat C receives foo() before `Disembargo`, thus allowing it to correctly deliver foo() + # before delivering bar(). + # - Vat C receives `Disembargo` from Vat B. It can now send a `Return` for the `Accept` from + # Vat A, as well as deliver bar(). +} + +# Level 4 message types ---------------------------------------------- + +struct Join { + # **(level 4)** + # + # Message type sent to implement E.join(), which, given a number of capabilities that are + # expected to be equivalent, finds the underlying object upon which they all agree and forms a + # direct connection to it, skipping any proxies that may have been constructed by other vats + # while transmitting the capability. See: + # http://erights.org/elib/equality/index.html + # + # Note that this should only serve to bypass fully-transparent proxies -- proxies that were + # created merely for convenience, without any intention of hiding the underlying object. + # + # For example, say Bob holds two capabilities hosted by Alice and Carol, but he expects that both + # are simply proxies for a capability hosted elsewhere. He then issues a join request, which + # operates as follows: + # - Bob issues Join requests on both Alice and Carol. Each request contains a different piece + # of the JoinKey. + # - Alice is proxying a capability hosted by Dana, so forwards the request to Dana's cap. + # - Dana receives the first request and sees that the JoinKeyPart is one of two. She notes that + # she doesn't have the other part yet, so she records the request and responds with a + # JoinResult. + # - Alice relays the JoinAnswer back to Bob. + # - Carol is also proxying a capability from Dana, and so forwards her Join request to Dana as + # well. + # - Dana receives Carol's request and notes that she now has both parts of a JoinKey. She + # combines them in order to form information needed to form a secure connection to Bob. She + # also responds with another JoinResult. + # - Bob receives the responses from Alice and Carol. He uses the returned JoinResults to + # determine how to connect to Dana and attempts to form the connection. Since Bob and Dana now + # agree on a secret key that neither Alice nor Carol ever saw, this connection can be made + # securely even if Alice or Carol is conspiring against the other. (If Alice and Carol are + # conspiring _together_, they can obviously reproduce the key, but this doesn't matter because + # the whole point of the join is to verify that Alice and Carol agree on what capability they + # are proxying.) + # + # If the two capabilities aren't actually proxies of the same object, then the join requests + # will come back with conflicting `hostId`s and the join will fail before attempting to form any + # connection. + + questionId @0 :QuestionId; + # Question ID used to respond to this Join. (Note that this ID only identifies one part of the + # request for one hop; each part has a different ID and relayed copies of the request have + # (probably) different IDs still.) + # + # The receiver will reply with a `Return` whose `results` is a JoinResult. This `JoinResult` + # is relayed from the joined object's host, possibly with transformation applied as needed + # by the network. + # + # Like any return, the result must be released using a `Finish`. However, this release + # should not occur until the joiner has either successfully connected to the joined object. + # Vats relaying a `Join` message similarly must not release the result they receive until the + # return they relayed back towards the joiner has itself been released. This allows the + # joined object's host to detect when the Join operation is canceled before completing -- if + # it receives a `Finish` for one of the join results before the joiner successfully + # connects. It can then free any resources it had allocated as part of the join. + + target @1 :MessageTarget; + # The capability to join. + + keyPart @2 :JoinKeyPart; + # A part of the join key. These combine to form the complete join key, which is used to establish + # a direct connection. + + # TODO(before implementing): Change this so that multiple parts can be sent in a single Join + # message, so that if multiple join parts are going to cross the same connection they can be sent + # together, so that the receive can potentially optimize its handling of them. In the case where + # all parts are bundled together, should the recipient be expected to simply return a cap, so + # that the caller can immediately start pipelining to it? +} + +# ======================================================================================== +# Common structures used in messages + +struct MessageTarget { + # The target of a `Call` or other messages that target a capability. + + union { + importedCap @0 :ImportId; + # This message is to a capability or promise previously imported by the caller (exported by + # the receiver). + + promisedAnswer @1 :PromisedAnswer; + # This message is to a capability that is expected to be returned by another call that has not + # yet been completed. + # + # At level 0, this is supported only for addressing the result of a previous `Bootstrap`, so + # that initial startup doesn't require a round trip. + } +} + +struct Payload { + # Represents some data structure that might contain capabilities. + + content @0 :AnyPointer; + # Some Cap'n Proto data structure. Capability pointers embedded in this structure index into + # `capTable`. + + capTable @1 :List(CapDescriptor); + # Descriptors corresponding to the cap pointers in `content`. +} + +struct CapDescriptor { + # **(level 1)** + # + # When an application-defined type contains an interface pointer, that pointer contains an index + # into the message's capability table -- i.e. the `capTable` part of the `Payload`. Each + # capability in the table is represented as a `CapDescriptor`. The runtime API should not reveal + # the CapDescriptor directly to the application, but should instead wrap it in some kind of + # callable object with methods corresponding to the interface that the capability implements. + # + # Keep in mind that `ExportIds` in a `CapDescriptor` are subject to reference counting. See the + # description of `ExportId`. + # + # Note that it is currently not possible to include a broken capability in the CapDescriptor + # table. Instead, create a new export (`senderPromise`) for each broken capability and then + # immediately follow the payload-bearing Call or Return message with one Resolve message for each + # broken capability, resolving it to an exception. + + union { + none @0 :Void; + # There is no capability here. This `CapDescriptor` should not appear in the payload content. + # A `none` CapDescriptor can be generated when an application inserts a capability into a + # message and then later changes its mind and removes it -- rewriting all of the other + # capability pointers may be hard, so instead a tombstone is left, similar to the way a removed + # struct or list instance is zeroed out of the message but the space is not reclaimed. + # Hopefully this is unusual. + + senderHosted @1 :ExportId; + # The ID of a capability in the sender's export table (receiver's import table). It may be a + # newly allocated table entry, or an existing entry (increments the reference count). + + senderPromise @2 :ExportId; + # A promise that the sender will resolve later. The sender will send exactly one Resolve + # message at a future point in time to replace this promise. Note that even if the same + # `senderPromise` is received multiple times, only one `Resolve` is sent to cover all of + # them. If `senderPromise` is released before the `Resolve` is sent, the sender (of this + # `CapDescriptor`) may choose not to send the `Resolve` at all. + + receiverHosted @3 :ImportId; + # A capability (or promise) previously exported by the receiver (imported by the sender). + + receiverAnswer @4 :PromisedAnswer; + # A capability expected to be returned in the results of a currently-outstanding call posed + # by the sender. + + thirdPartyHosted @5 :ThirdPartyCapDescriptor; + # **(level 3)** + # + # A capability that lives in neither the sender's nor the receiver's vat. The sender needs + # to form a direct connection to a third party to pick up the capability. + # + # Level 1 and 2 implementations that receive a `thirdPartyHosted` may simply send calls to its + # `vine` instead. + } + + attachedFd @6 :UInt8 = 0xff; + # If the RPC message in which this CapDescriptor was delivered also had file descriptors + # attached, and `fd` is a valid index into the list of attached file descriptors, then + # that file descriptor should be attached to this capability. If `attachedFd` is out-of-bounds + # for said list, then no FD is attached. + # + # For example, if the RPC message arrived over a Unix socket, then file descriptors may be + # attached by sending an SCM_RIGHTS ancillary message attached to the data bytes making up the + # raw message. Receivers who wish to opt into FD passing should arrange to receive SCM_RIGHTS + # whenever receiving an RPC message. Senders who wish to send FDs need not verify whether the + # receiver knows how to receive them, because the operating system will automatically discard + # ancillary messages like SCM_RIGHTS if the receiver doesn't ask to receive them, including + # automatically closing any FDs. + # + # It is up to the application protocol to define what capabilities are expected to have file + # descriptors attached, and what those FDs mean. But, for example, an application could use this + # to open a file on disk and then transmit the open file descriptor to a sandboxed process that + # does not otherwise have permission to access the filesystem directly. This is usually an + # optimization: the sending process could instead provide an RPC interface supporting all the + # operations needed (such as reading and writing a file), but by passing the file descriptor + # directly, the recipient can often perform operations much more efficiently. Application + # designers are encouraged to provide such RPC interfaces and automatically fall back to them + # when FD passing is not available, so that the application can still work when the parties are + # remote over a network. + # + # An attached FD is most often associated with a `senderHosted` descriptor. It could also make + # sense in the case of `thirdPartyHosted`: in this case, the sender is forwarding the FD that + # they received from the third party, so that the receiver can start using it without first + # interacting with the third party. This is an optional optimization -- the middleman may choose + # not to forward capabilities, in which case the receiver will need to complete the handshake + # with the third party directly before receiving the FD. If an implementation receives a second + # attached FD after having already received one previously (e.g. both in a `thirdPartyHosted` + # CapDescriptor and then later again when receiving the final capability directly from the + # third party), the implementation should discard the later FD and stick with the original. At + # present, there is no known reason why other capability types (e.g. `receiverHosted`) would want + # to carry an attached FD, but we reserve the right to define a meaning for this in the future. + # + # Each file descriptor attached to the message must be used in no more than one CapDescriptor, + # so that the receiver does not need to use dup() or refcounting to handle the possibility of + # multiple capabilities using the same descriptor. If multiple CapDescriptors do point to the + # same FD index, then the receiver can arbitrarily choose which capability ends up having the + # FD attached. + # + # To mitigate DoS attacks, RPC implementations should limit the number of FDs they are willing to + # receive in a single message to a small value. If a message happens to contain more than that, + # the list is truncated. Moreover, in some cases, FD passing needs to be blocked entirely for + # security or implementation reasons, in which case the list may be truncated to zero. Hence, + # `attachedFd` might point past the end of the list, which the implementation should treat as if + # no FD was attached at all. + # + # The type of this field was chosen to be UInt8 because Linux supports sending only a maximum + # of 253 file descriptors in an SCM_RIGHTS message anyway, and CapDescriptor had two bytes of + # padding left -- so after adding this, there is still one byte for a future feature. + # Conveniently, this also means we're able to use 0xff as the default value, which will always + # be out-of-range (of course, the implementation should explicitly enforce that 255 descriptors + # cannot be sent at once, rather than relying on Linux to do so). +} + +struct PromisedAnswer { + # **(mostly level 1)** + # + # Specifies how to derive a promise from an unanswered question, by specifying the path of fields + # to follow from the root of the eventual result struct to get to the desired capability. Used + # to address method calls to a not-yet-returned capability or to pass such a capability as an + # input to some other method call. + # + # Level 0 implementations must support `PromisedAnswer` only for the case where the answer is + # to a `Bootstrap` message. In this case, `path` is always empty since `Bootstrap` always returns + # a raw capability. + + questionId @0 :QuestionId; + # ID of the question (in the sender's question table / receiver's answer table) whose answer is + # expected to contain the capability. + + transform @1 :List(Op); + # Operations / transformations to apply to the result in order to get the capability actually + # being addressed. E.g. if the result is a struct and you want to call a method on a capability + # pointed to by a field of the struct, you need a `getPointerField` op. + + struct Op { + union { + noop @0 :Void; + # Does nothing. This member is mostly defined so that we can make `Op` a union even + # though (as of this writing) only one real operation is defined. + + getPointerField @1 :UInt16; + # Get a pointer field within a struct. The number is an index into the pointer section, NOT + # a field ordinal, so that the receiver does not need to understand the schema. + + # TODO(someday): We could add: + # - For lists, the ability to address every member of the list, or a slice of the list, the + # result of which would be another list. This is useful for implementing the equivalent of + # a SQL table join (not to be confused with the `Join` message type). + # - Maybe some ability to test a union. + # - Probably not a good idea: the ability to specify an arbitrary script to run on the + # result. We could define a little stack-based language where `Op` specifies one + # "instruction" or transformation to apply. Although this is not a good idea + # (over-engineered), any narrower additions to `Op` should be designed as if this + # were the eventual goal. + } + } +} + +struct ThirdPartyCapDescriptor { + # **(level 3)** + # + # Identifies a capability in a third-party vat that the sender wants the receiver to pick up. + + id @0 :ThirdPartyCapId; + # Identifies the third-party host and the specific capability to accept from it. + + vineId @1 :ExportId; + # A proxy for the third-party object exported by the sender. In CapTP terminology this is called + # a "vine", because it is an indirect reference to the third-party object that snakes through the + # sender vat. This serves two purposes: + # + # * Level 1 and 2 implementations that don't understand how to connect to a third party may + # simply send calls to the vine. Such calls will be forwarded to the third-party by the + # sender. + # + # * Level 3 implementations must release the vine only once they have successfully picked up the + # object from the third party. This ensures that the capability is not released by the sender + # prematurely. + # + # The sender will close the `Provide` request that it has sent to the third party as soon as + # it receives either a `Call` or a `Release` message directed at the vine. +} + +struct Exception { + # **(level 0)** + # + # Describes an arbitrary error that prevented an operation (e.g. a call) from completing. + # + # Cap'n Proto exceptions always indicate that something went wrong. In other words, in a fantasy + # world where everything always works as expected, no exceptions would ever be thrown. Clients + # should only ever catch exceptions as a means to implement fault-tolerance, where "fault" can + # mean: + # - Bugs. + # - Invalid input. + # - Configuration errors. + # - Network problems. + # - Insufficient resources. + # - Version skew (unimplemented functionality). + # - Other logistical problems. + # + # Exceptions should NOT be used to flag application-specific conditions that a client is expected + # to handle in an application-specific way. Put another way, in the Cap'n Proto world, + # "checked exceptions" (where an interface explicitly defines the exceptions it throws and + # clients are forced by the type system to handle those exceptions) do NOT make sense. + + reason @0 :Text; + # Human-readable failure description. + + type @3 :Type; + # The type of the error. The purpose of this enum is not to describe the error itself, but + # rather to describe how the client might want to respond to the error. + + enum Type { + failed @0; + # A generic problem occurred, and it is believed that if the operation were repeated without + # any change in the state of the world, the problem would occur again. + # + # A client might respond to this error by logging it for investigation by the developer and/or + # displaying it to the user. + + overloaded @1; + # The request was rejected due to a temporary lack of resources. + # + # Examples include: + # - There's not enough CPU time to keep up with incoming requests, so some are rejected. + # - The server ran out of RAM or disk space during the request. + # - The operation timed out (took significantly longer than it should have). + # + # A client might respond to this error by scheduling to retry the operation much later. The + # client should NOT retry again immediately since this would likely exacerbate the problem. + + disconnected @2; + # The method failed because a connection to some necessary capability was lost. + # + # Examples include: + # - The client introduced the server to a third-party capability, the connection to that third + # party was subsequently lost, and then the client requested that the server use the dead + # capability for something. + # - The client previously requested that the server obtain a capability from some third party. + # The server returned a capability to an object wrapping the third-party capability. Later, + # the server's connection to the third party was lost. + # - The capability has been revoked. Revocation does not necessarily mean that the client is + # no longer authorized to use the capability; it is often used simply as a way to force the + # client to repeat the setup process, perhaps to efficiently move them to a new back-end or + # get them to recognize some other change that has occurred. + # + # A client should normally respond to this error by releasing all capabilities it is currently + # holding related to the one it called and then re-creating them by restoring SturdyRefs and/or + # repeating the method calls used to create them originally. In other words, disconnect and + # start over. This should in turn cause the server to obtain a new copy of the capability that + # it lost, thus making everything work. + # + # If the client receives another `disconnected` error in the process of rebuilding the + # capability and retrying the call, it should treat this as an `overloaded` error: the network + # is currently unreliable, possibly due to load or other temporary issues. + + unimplemented @3; + # The server doesn't implement the requested method. If there is some other method that the + # client could call (perhaps an older and/or slower interface), it should try that instead. + # Otherwise, this should be treated like `failed`. + } + + obsoleteIsCallersFault @1 :Bool; + # OBSOLETE. Ignore. + + obsoleteDurability @2 :UInt16; + # OBSOLETE. See `type` instead. +} + +# ======================================================================================== +# Network-specific Parameters +# +# Some parts of the Cap'n Proto RPC protocol are not specified here because different vat networks +# may wish to use different approaches to solving them. For example, on the public internet, you +# may want to authenticate vats using public-key cryptography, but on a local intranet with trusted +# infrastructure, you may be happy to authenticate based on network address only, or some other +# lightweight mechanism. +# +# To accommodate this, we specify several "parameter" types. Each type is defined here as an +# alias for `AnyPointer`, but a specific network will want to define a specific set of types to use. +# All vats in a vat network must agree on these parameters in order to be able to communicate. +# Inter-network communication can be accomplished through "gateways" that perform translation +# between the primitives used on each network; these gateways may need to be deeply stateful, +# depending on the translations they perform. +# +# For interaction over the global internet between parties with no other prior arrangement, a +# particular set of bindings for these types is defined elsewhere. (TODO(someday): Specify where +# these common definitions live.) +# +# Another common network type is the two-party network, in which one of the parties typically +# interacts with the outside world entirely through the other party. In such a connection between +# Alice and Bob, all objects that exist on Bob's other networks appear to Alice as if they were +# hosted by Bob himself, and similarly all objects on Alice's network (if she even has one) appear +# to Bob as if they were hosted by Alice. This network type is interesting because from the point +# of view of a simple application that communicates with only one other party via the two-party +# protocol, there are no three-party interactions at all, and joins are unusually simple to +# implement, so implementing at level 4 is barely more complicated than implementing at level 1. +# Moreover, if you pair an app implementing the two-party network with a container that implements +# some other network, the app can then participate on the container's network just as if it +# implemented that network directly. The types used by the two-party network are defined in +# `rpc-twoparty.capnp`. +# +# The things that we need to parameterize are: +# - How to store capabilities long-term without holding a connection open (mostly level 2). +# - How to authenticate vats in three-party introductions (level 3). +# - How to implement `Join` (level 4). +# +# Persistent references +# --------------------- +# +# **(mostly level 2)** +# +# We want to allow some capabilities to be stored long-term, even if a connection is lost and later +# recreated. ExportId is a short-term identifier that is specific to a connection, so it doesn't +# help here. We need a way to specify long-term identifiers, as well as a strategy for +# reconnecting to a referenced capability later. +# +# Three-party interactions +# ------------------------ +# +# **(level 3)** +# +# In cases where more than two vats are interacting, we have situations where VatA holds a +# capability hosted by VatB and wants to send that capability to VatC. This can be accomplished +# by VatA proxying requests on the new capability, but doing so has two big problems: +# - It's inefficient, requiring an extra network hop. +# - If VatC receives another capability to the same object from VatD, it is difficult for VatC to +# detect that the two capabilities are really the same and to implement the E "join" operation, +# which is necessary for certain four-or-more-party interactions, such as the escrow pattern. +# See: http://www.erights.org/elib/equality/grant-matcher/index.html +# +# Instead, we want a way for VatC to form a direct, authenticated connection to VatB. +# +# Join +# ---- +# +# **(level 4)** +# +# The `Join` message type and corresponding operation arranges for a direct connection to be formed +# between the joiner and the host of the joined object, and this connection must be authenticated. +# Thus, the details are network-dependent. + +using SturdyRef = AnyPointer; +# **(level 2)** +# +# Identifies a persisted capability that can be restored in the future. How exactly a SturdyRef +# is restored to a live object is specified along with the SturdyRef definition (i.e. not by +# rpc.capnp). +# +# Generally a SturdyRef needs to specify three things: +# - How to reach the vat that can restore the ref (e.g. a hostname or IP address). +# - How to authenticate the vat after connecting (e.g. a public key fingerprint). +# - The identity of a specific object hosted by the vat. Generally, this is an opaque pointer whose +# format is defined by the specific vat -- the client has no need to inspect the object ID. +# It is important that the object ID be unguessable if the object is not public (and objects +# should almost never be public). +# +# The above are only suggestions. Some networks might work differently. For example, a private +# network might employ a special restorer service whose sole purpose is to restore SturdyRefs. +# In this case, the entire contents of SturdyRef might be opaque, because they are intended only +# to be forwarded to the restorer service. + +using ProvisionId = AnyPointer; +# **(level 3)** +# +# The information that must be sent in an `Accept` message to identify the object being accepted. +# +# In a network where each vat has a public/private key pair, this could simply be the public key +# fingerprint of the provider vat along with a nonce matching the one in the `RecipientId` used +# in the `Provide` message sent from that provider. + +using RecipientId = AnyPointer; +# **(level 3)** +# +# The information that must be sent in a `Provide` message to identify the recipient of the +# capability. +# +# In a network where each vat has a public/private key pair, this could simply be the public key +# fingerprint of the recipient along with a nonce matching the one in the `ProvisionId`. +# +# As another example, when communicating between processes on the same machine over Unix sockets, +# RecipientId could simply refer to a file descriptor attached to the message via SCM_RIGHTS. +# This file descriptor would be one end of a newly-created socketpair, with the other end having +# been sent to the capability's recipient in ThirdPartyCapId. + +using ThirdPartyCapId = AnyPointer; +# **(level 3)** +# +# The information needed to connect to a third party and accept a capability from it. +# +# In a network where each vat has a public/private key pair, this could be a combination of the +# third party's public key fingerprint, hints on how to connect to the third party (e.g. an IP +# address), and the nonce used in the corresponding `Provide` message's `RecipientId` as sent +# to that third party (used to identify which capability to pick up). +# +# As another example, when communicating between processes on the same machine over Unix sockets, +# ThirdPartyCapId could simply refer to a file descriptor attached to the message via SCM_RIGHTS. +# This file descriptor would be one end of a newly-created socketpair, with the other end having +# been sent to the process hosting the capability in RecipientId. + +using JoinKeyPart = AnyPointer; +# **(level 4)** +# +# A piece of a secret key. One piece is sent along each path that is expected to lead to the same +# place. Once the pieces are combined, a direct connection may be formed between the sender and +# the receiver, bypassing any men-in-the-middle along the paths. See the `Join` message type. +# +# The motivation for Joins is discussed under "Supporting Equality" in the "Unibus" protocol +# sketch: http://www.erights.org/elib/distrib/captp/unibus.html +# +# In a network where each vat has a public/private key pair and each vat forms no more than one +# connection to each other vat, Joins will rarely -- perhaps never -- be needed, as objects never +# need to be transparently proxied and references to the same object sent over the same connection +# have the same export ID. Thus, a successful join requires only checking that the two objects +# come from the same connection and have the same ID, and then completes immediately. +# +# However, in networks where two vats may form more than one connection between each other, or +# where proxying of objects occurs, joins are necessary. +# +# Typically, each JoinKeyPart would include a fixed-length data value such that all value parts +# XOR'd together forms a shared secret that can be used to form an encrypted connection between +# the joiner and the joined object's host. Each JoinKeyPart should also include an indication of +# how many parts to expect and a hash of the shared secret (used to match up parts). + +using JoinResult = AnyPointer; +# **(level 4)** +# +# Information returned as the result to a `Join` message, needed by the joiner in order to form a +# direct connection to a joined object. This might simply be the address of the joined object's +# host vat, since the `JoinKey` has already been communicated so the two vats already have a shared +# secret to use to authenticate each other. +# +# The `JoinResult` should also contain information that can be used to detect when the Join +# requests ended up reaching different objects, so that this situation can be detected easily. +# This could be a simple matter of including a sequence number -- if the joiner receives two +# `JoinResult`s with sequence number 0, then they must have come from different objects and the +# whole join is a failure. + +# ======================================================================================== +# Network interface sketch +# +# The interfaces below are meant to be pseudo-code to illustrate how the details of a particular +# vat network might be abstracted away. They are written like Cap'n Proto interfaces, but in +# practice you'd probably define these interfaces manually in the target programming language. A +# Cap'n Proto RPC implementation should be able to use these interfaces without knowing the +# definitions of the various network-specific parameters defined above. + +# interface VatNetwork { +# # Represents a vat network, with the ability to connect to particular vats and receive +# # connections from vats. +# # +# # Note that methods returning a `Connection` may return a pre-existing `Connection`, and the +# # caller is expected to find and share state with existing users of the connection. +# +# # Level 0 features ----------------------------------------------- +# +# connect(vatId :VatId) :Connection; +# # Connect to the given vat. The transport should return a promise that does not +# # resolve until authentication has completed, but allows messages to be pipelined in before +# # that; the transport either queues these messages until authenticated, or sends them encrypted +# # such that only the authentic vat would be able to decrypt them. The latter approach avoids a +# # round trip for authentication. +# +# accept() :Connection; +# # Wait for the next incoming connection and return it. Only connections formed by +# # connect() are returned by this method. +# +# # Level 4 features ----------------------------------------------- +# +# newJoiner(count :UInt32) :NewJoinerResponse; +# # Prepare a new Join operation, which will eventually lead to forming a new direct connection +# # to the host of the joined capability. `count` is the number of capabilities to join. +# +# struct NewJoinerResponse { +# joinKeyParts :List(JoinKeyPart); +# # Key parts to send in Join messages to each capability. +# +# joiner :Joiner; +# # Used to establish the final connection. +# } +# +# interface Joiner { +# addJoinResult(result :JoinResult) :Void; +# # Add a JoinResult received in response to one of the `Join` messages. All `JoinResult`s +# # returned from all paths must be added before trying to connect. +# +# connect() :ConnectionAndProvisionId; +# # Try to form a connection to the joined capability's host, verifying that it has received +# # all of the JoinKeyParts. Once the connection is formed, the caller should send an `Accept` +# # message on it with the specified `ProvisionId` in order to receive the final capability. +# } +# +# acceptConnectionFromJoiner(parts :List(JoinKeyPart), paths :List(VatPath)) +# :ConnectionAndProvisionId; +# # Called on a joined capability's host to receive the connection from the joiner, once all +# # key parts have arrived. The caller should expect to receive an `Accept` message over the +# # connection with the given ProvisionId. +# } +# +# interface Connection { +# # Level 0 features ----------------------------------------------- +# +# send(message :Message) :Void; +# # Send the message. Returns successfully when the message (and all preceding messages) has +# # been acknowledged by the recipient. +# +# receive() :Message; +# # Receive the next message, and acknowledges receipt to the sender. Messages are received in +# # the order in which they are sent. +# +# # Level 3 features ----------------------------------------------- +# +# introduceTo(recipient :Connection) :IntroductionInfo; +# # Call before starting a three-way introduction, assuming a `Provide` message is to be sent on +# # this connection and a `ThirdPartyCapId` is to be sent to `recipient`. +# +# struct IntroductionInfo { +# sendToRecipient :ThirdPartyCapId; +# sendToTarget :RecipientId; +# } +# +# connectToIntroduced(capId :ThirdPartyCapId) :ConnectionAndProvisionId; +# # Given a ThirdPartyCapId received over this connection, connect to the third party. The +# # caller should then send an `Accept` message over the new connection. +# +# acceptIntroducedConnection(recipientId :RecipientId) :Connection; +# # Given a RecipientId received in a `Provide` message on this `Connection`, wait for the +# # recipient to connect, and return the connection formed. Usually, the first message received +# # on the new connection will be an `Accept` message. +# } +# +# struct ConnectionAndProvisionId { +# # **(level 3)** +# +# connection :Connection; +# # Connection on which to issue `Accept` message. +# +# provision :ProvisionId; +# # `ProvisionId` to send in the `Accept` message. +# } diff --git a/runtime/src/test/java/org/capnproto/CapabilityTest.java b/runtime-rpc/src/test/java/org/capnproto/CapabilityTest.java similarity index 98% rename from runtime/src/test/java/org/capnproto/CapabilityTest.java rename to runtime-rpc/src/test/java/org/capnproto/CapabilityTest.java index cdfb2bb..bb732be 100644 --- a/runtime/src/test/java/org/capnproto/CapabilityTest.java +++ b/runtime-rpc/src/test/java/org/capnproto/CapabilityTest.java @@ -1,3 +1,5 @@ +package org.capnproto; + // Copyright (c) 2018 Sandstorm Development Group, Inc. and contributors // Licensed under the MIT License: // @@ -19,8 +21,10 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. -package org.capnproto; - +import org.capnproto.AnyPointer; +import org.capnproto.CallContext; +import org.capnproto.Capability; +import org.capnproto.RpcException; import org.capnproto.test.Test; import org.junit.Assert; diff --git a/runtime/src/test/java/org/capnproto/RpcStateTest.java b/runtime-rpc/src/test/java/org/capnproto/RpcStateTest.java similarity index 98% rename from runtime/src/test/java/org/capnproto/RpcStateTest.java rename to runtime-rpc/src/test/java/org/capnproto/RpcStateTest.java index 173bdc4..35636d1 100644 --- a/runtime/src/test/java/org/capnproto/RpcStateTest.java +++ b/runtime-rpc/src/test/java/org/capnproto/RpcStateTest.java @@ -117,7 +117,7 @@ public class RpcStateTest { public void handleAbort() { var msg = new TestMessage(); var builder = msg.builder.getRoot(RpcProtocol.Message.factory); - RpcException.fromException(RpcException.failed("Test abort"), builder.initAbort()); + RpcState.FromException(RpcException.failed("Test abort"), builder.initAbort()); this.connection.setNextIncomingMessage(msg); //Assert.assertThrows(RpcException.class, () -> rpc.handleMessage(msg)); } diff --git a/runtime-rpc/src/test/java/org/capnproto/RpcTest.java b/runtime-rpc/src/test/java/org/capnproto/RpcTest.java new file mode 100644 index 0000000..609747a --- /dev/null +++ b/runtime-rpc/src/test/java/org/capnproto/RpcTest.java @@ -0,0 +1,410 @@ +// Copyright (c) 2018 Sandstorm Development Group, Inc. and contributors +// Licensed under the MIT License: +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +package org.capnproto; + +import org.capnproto.test.Test; + +import org.junit.Assert; + +import java.util.ArrayDeque; +import java.util.HashMap; +import java.util.Map; +import java.util.Queue; +import java.util.concurrent.CompletableFuture; + +public class RpcTest { + + final class TestNetwork { + + final Map map = new HashMap<>(); + int received = 0; + + TestNetworkAdapter add(String name) { + return this.map.computeIfAbsent( + name, key -> new TestNetworkAdapter(this, name)); + } + + TestNetworkAdapter find(String name) { + return this.map.get(name); + } + } + + final class TestNetworkAdapter + implements VatNetwork { + + @Override + public CompletableFuture> baseAccept() { + return this.accept().thenApply(conn -> conn); + } + + class Connection implements VatNetwork.Connection { + + Throwable networkException; + Connection partner; + final Queue messages = new ArrayDeque<>(); + final Queue> fulfillers = new ArrayDeque<>(); + CompletableFuture fulfillOnEnd; + final boolean isClient; + final Test.TestSturdyRef.Reader peerId; + + Connection(boolean isClient, Test.TestSturdyRef.Reader peerId) { + this.isClient = isClient; + this.peerId = peerId; + } + + void attach(Connection other) { + Assert.assertNull(this.partner); + Assert.assertNull(other.partner); + this.partner = other; + other.partner = this; + } + + TestNetwork getNetwork() { + return network; + } + + @Override + public OutgoingRpcMessage newOutgoingMessage(int firstSegmentWordSize) { + var message = new MessageBuilder(firstSegmentWordSize); + + return new OutgoingRpcMessage() { + @Override + public AnyPointer.Builder getBody() { + return message.getRoot(AnyPointer.factory); + } + + @Override + public void send() { + if (networkException != null) { + return; + } + + var incomingMessage = new IncomingRpcMessage() { + @Override + public AnyPointer.Reader getBody() { + return message.getRoot(AnyPointer.factory).asReader(); + } + }; + + if (partner == null) { + return; + } + + if (partner.fulfillers.isEmpty()) { + partner.messages.add(incomingMessage); + } + else { + partner.getNetwork().received++; + var front = partner.fulfillers.remove(); + front.complete(incomingMessage); + } + } + + @Override + public int sizeInWords() { + return 0; + } + }; + } + + @Override + public CompletableFuture receiveIncomingMessage() { + if (this.networkException != null) { + return CompletableFuture.failedFuture(this.networkException); + } + + if (this.messages.isEmpty()) { + if (this.fulfillOnEnd != null) { + this.fulfillOnEnd.complete(null); + return CompletableFuture.completedFuture(null); + } + else { + var promise = new CompletableFuture(); + this.fulfillers.add(promise); + return promise.copy(); + } + } + else { + this.getNetwork().received++; + var result = this.messages.remove(); + return CompletableFuture.completedFuture(result); + } + } + + @Override + public CompletableFuture onDisconnect() { + return null; + } + + @Override + public CompletableFuture shutdown() { + if (this.partner == null) { + return CompletableFuture.completedFuture(null); + } + var promise = new CompletableFuture(); + this.partner.fulfillOnEnd = promise; + return promise.copy(); + } + + public Test.TestSturdyRef.Reader getPeerVatId() { + return this.peerId; + } + } + + final TestNetwork network; + private final String self; + int sent = 0; + int received = 0; + Map connections = new HashMap<>(); + Queue> fulfillerQueue = new ArrayDeque<>(); + Queue connectionQueue = new ArrayDeque<>(); + + TestNetworkAdapter(TestNetwork network, String self) { + this.network = network; + this.self = self; + } + + Connection newConnection(boolean isClient, Test.TestSturdyRef.Reader peerId) { + return new Connection(isClient, peerId); + } + + @Override + public VatNetwork.Connection connect(Test.TestSturdyRef.Reader refId) { + var hostId = refId.getHostId().getHost().toString(); + if (hostId.equals(self)) { + return null; + } + + var dst = this.network.find(hostId); + Assert.assertNotNull(dst); + + var connnection = this.connections.get(dst); + if (connnection != null) { + return connnection; + } + + var local = this.newConnection(true, refId); + var remote = dst.newConnection(false, refId); + local.attach(remote); + + this.connections.put(dst, local); + dst.connections.put(this, remote); + + if (dst.fulfillerQueue.isEmpty()) { + dst.fulfillerQueue.add(CompletableFuture.completedFuture(remote)); + } else { + dst.fulfillerQueue.remove().complete(remote); + } + return local; + } + + public CompletableFuture accept() { + if (this.connections.isEmpty()) { + var promise = new CompletableFuture(); + this.fulfillerQueue.add(promise); + return promise.thenApply(conn -> conn); + } + else { + return CompletableFuture.completedFuture(this.connectionQueue.remove()); + } + } + } + + final class TestContext { + final TestNetwork network = new TestNetwork(); + final TestNetworkAdapter clientNetwork; + final TestNetworkAdapter serverNetwork; + + final RpcSystem rpcClient; + final RpcSystem rpcServer; + + TestContext(Capability.Client bootstrapInterface) { + this.clientNetwork = this.network.add("client"); + this.serverNetwork = this.network.add("server"); + this.rpcClient = RpcSystem.makeRpcClient(this.clientNetwork); + this.rpcServer = RpcSystem.makeRpcServer(this.serverNetwork, bootstrapInterface); + } + + TestContext(BootstrapFactory bootstrapFactory) { + this.clientNetwork = this.network.add("client"); + this.serverNetwork = this.network.add("server"); + this.rpcClient = RpcSystem.makeRpcClient(this.clientNetwork); + this.rpcServer = RpcSystem.makeRpcServer(this.serverNetwork, bootstrapFactory); + } + + Capability.Client connect(Test.TestSturdyRefObjectId.Tag tag) { + var message = new MessageBuilder(); + var ref = message.initRoot(Test.TestSturdyRef.factory); + var hostId = ref.initHostId(); + hostId.setHost("server"); + ref.getObjectId().initAs(Test.TestSturdyRefObjectId.factory).setTag(tag); + return rpcClient.bootstrap(ref.asReader()); + } + } + + static BootstrapFactory bootstrapFactory = new BootstrapFactory<>() { + @Override + public FromPointerReader getVatIdFactory() { + return Test.TestSturdyRef.factory; + } + + @Override + public Capability.Client createFor(Test.TestSturdyRef.Reader refId) { + var callCount = new Counter(); + var handleCount = new Counter(); + + var objectId = refId.getObjectId().getAs(Test.TestSturdyRefObjectId.factory); + var tag = objectId.getTag(); + switch (tag) { + case TEST_INTERFACE: + return new Capability.Client(new TestUtil.TestInterfaceImpl(callCount)); + case TEST_EXTENDS: + return new Capability.Client(Capability.newBrokenCap("No TestExtends implemented.")); + case TEST_PIPELINE: + return new Capability.Client(new TestUtil.TestPipelineImpl(callCount)); + case TEST_TAIL_CALLEE: + return new Capability.Client(new TestUtil.TestTailCalleeImpl(callCount)); + case TEST_TAIL_CALLER: + return new Capability.Client(new TestUtil.TestTailCallerImpl(callCount)); + case TEST_MORE_STUFF: + return new Capability.Client(new TestUtil.TestMoreStuffImpl(callCount, handleCount)); + default: + return new Capability.Client(); + } + } + }; + + @org.junit.Test + public void testBasic() { + var context = new TestContext(bootstrapFactory); + var client = new Test.TestInterface.Client(context.connect(Test.TestSturdyRefObjectId.Tag.TEST_INTERFACE)); + var request1 = client.fooRequest(); + request1.getParams().setI(123); + request1.getParams().setJ(true); + var promise1 = request1.send(); + + final var ref = new Object() { + boolean barFailed = false; + }; + var request3 = client.barRequest(); + var promise3 = request3.send().exceptionally(exc -> { + ref.barFailed = true; + return null; + }); + + var request2 = client.bazRequest(); + TestUtil.initTestMessage(request2.getParams().initS()); + var promise2 = request2.send(); + + var response1 = promise1.join(); + Assert.assertEquals("foo", response1.getX().toString()); + + var response2 = promise2.join(); + promise3.join(); + + Assert.assertTrue(ref.barFailed); + } + + @org.junit.Test + public void testPipelining() { + var context = new TestContext(bootstrapFactory); + var client = new Test.TestPipeline.Client(context.connect(Test.TestSturdyRefObjectId.Tag.TEST_PIPELINE)); + + var chainedCallCount = new Counter(); + + var request = client.getCapRequest(); + request.getParams().setN(234); + request.getParams().setInCap(new TestUtil.TestInterfaceImpl(chainedCallCount)); + + var promise = request.send(); + + var pipelineRequest = promise.getOutBox().getCap().fooRequest(); + pipelineRequest.getParams().setI(321); + + var pipelinePromise = pipelineRequest.send(); + + var pipelineRequest2 = new Test.TestExtends.Client(promise.getOutBox().getCap()).graultRequest(); + var pipelinePromise2 = pipelineRequest2.send(); + + promise = null; + + //Assert.assertEquals(0, chainedCallCount.value()); + + var response = pipelinePromise.join(); + Assert.assertEquals("bar", response.getX().toString()); + + var response2 = pipelinePromise2.join(); + TestUtil.checkTestMessage(response2); + + Assert.assertEquals(1, chainedCallCount.value()); + } + + @org.junit.Test + public void testRelease() { + var context = new TestContext(bootstrapFactory); + var client = new Test.TestMoreStuff.Client(context.connect(Test.TestSturdyRefObjectId.Tag.TEST_MORE_STUFF)); + + var handle1 = client.getHandleRequest().send().join().getHandle(); + var promise = client.getHandleRequest().send(); + var handle2 = promise.join().getHandle(); + + handle1 = null; + handle2 = null; + } + + @org.junit.Test + public void testPromiseResolve() { + var context = new TestContext(bootstrapFactory); + var client = new Test.TestMoreStuff.Client(context.connect(Test.TestSturdyRefObjectId.Tag.TEST_MORE_STUFF)); + + var chainedCallCount = new Counter(); + + var request = client.callFooRequest(); + var request2 = client.callFooWhenResolvedRequest(); + + var paf = new CompletableFuture(); + + { + request.getParams().setCap(new Test.TestInterface.Client(paf.copy())); + request2.getParams().setCap(new Test.TestInterface.Client(paf.copy())); + } + + var promise = request.send(); + var promise2 = request2.send(); + + // Make sure getCap() has been called on the server side by sending another call and waiting + // for it. + Assert.assertEquals(2, client.getCallSequenceRequest().send().join().getN()); + //Assert.assertEquals(3, context.restorer.callCount); + + // OK, now fulfill the local promise. + paf.complete(new Test.TestInterface.Client(new TestUtil.TestInterfaceImpl(chainedCallCount))); + + // We should now be able to wait for getCap() to finish. + Assert.assertEquals("bar", promise.join().getS().toString()); + Assert.assertEquals("bar", promise2.join().getS().toString()); + + //Assert.assertEquals(3, context.restorer.callCount); + Assert.assertEquals(2, chainedCallCount.value()); + } +} + diff --git a/runtime/src/test/java/org/capnproto/TestUtil.java b/runtime-rpc/src/test/java/org/capnproto/TestUtil.java similarity index 96% rename from runtime/src/test/java/org/capnproto/TestUtil.java rename to runtime-rpc/src/test/java/org/capnproto/TestUtil.java index 4f2c8ac..89a3dbc 100644 --- a/runtime/src/test/java/org/capnproto/TestUtil.java +++ b/runtime-rpc/src/test/java/org/capnproto/TestUtil.java @@ -1,11 +1,16 @@ package org.capnproto; +import org.capnproto.CallContext; +import org.capnproto.Capability; +import org.capnproto.Void; import org.capnproto.test.Test; import org.junit.Assert; import java.util.concurrent.CompletableFuture; class TestUtil { + + static void initTestMessage(Test.TestAllTypes.Builder builder) { builder.setVoidField(Void.VOID); builder.setBoolField(true); @@ -54,7 +59,7 @@ class TestUtil { Assert.assertEquals(123, params.getI()); Assert.assertTrue(params.getJ()); result.setX("foo"); - return READY_NOW; + return Capability.Server.READY_NOW; } @Override @@ -63,7 +68,7 @@ class TestUtil { var params = context.getParams(); checkTestMessage(params.getS()); context.releaseParams(); - return READY_NOW; + return Capability.Server.READY_NOW; } } @@ -112,14 +117,14 @@ class TestUtil { @Override protected CompletableFuture getHandle(CallContext context) { context.getResults().setHandle(new HandleImpl(this.handleCount)); - return READY_NOW; + return Capability.Server.READY_NOW; } @Override protected CompletableFuture getCallSequence(CallContext context) { var result = context.getResults(); result.setN(this.callCount.inc()); - return READY_NOW; + return Capability.Server.READY_NOW; } @Override @@ -174,7 +179,7 @@ class TestUtil { results.setI(params.getI()); results.setT(params.getT()); results.setC(new TestCallOrderImpl()); - return READY_NOW; + return Capability.Server.READY_NOW; } } diff --git a/runtime/src/test/java/org/capnproto/TwoPartyTest.java b/runtime-rpc/src/test/java/org/capnproto/TwoPartyTest.java similarity index 96% rename from runtime/src/test/java/org/capnproto/TwoPartyTest.java rename to runtime-rpc/src/test/java/org/capnproto/TwoPartyTest.java index 43618f5..222007c 100644 --- a/runtime/src/test/java/org/capnproto/TwoPartyTest.java +++ b/runtime-rpc/src/test/java/org/capnproto/TwoPartyTest.java @@ -1,4 +1,5 @@ package org.capnproto; + /* import org.capnproto.demo.Demo; import org.junit.After; @@ -42,7 +43,7 @@ class TestCap0Impl extends Demo.TestCap0.Server { class TestCap1Impl extends Demo.TestCap1.Server { } -class Tap implements TwoPartyVatNetwork.MessageTap { +class Tap implements org.capnproto.TwoPartyVatNetwork.MessageTap { final RpcDumper dumper = new RpcDumper(); @@ -57,7 +58,7 @@ class Tap implements TwoPartyVatNetwork.MessageTap { public class TwoPartyTest { - private Thread runServer(TwoPartyVatNetwork network) { + private Thread runServer(org.capnproto.TwoPartyVatNetwork network) { var thread = new Thread(() -> { try { network.onDisconnect().get(); @@ -75,7 +76,7 @@ public class TwoPartyTest { AsynchronousServerSocketChannel serverSocket; AsynchronousSocketChannel clientSocket; TwoPartyClient client; - TwoPartyVatNetwork serverNetwork; + org.capnproto.TwoPartyVatNetwork serverNetwork; Thread serverThread; @Before @@ -89,7 +90,7 @@ public class TwoPartyTest { this.client.getNetwork().setTap(new Tap()); var socket = serverSocket.accept().get(); - this.serverNetwork = new TwoPartyVatNetwork(socket, RpcTwoPartyProtocol.Side.SERVER); + this.serverNetwork = new org.capnproto.TwoPartyVatNetwork(socket, RpcTwoPartyProtocol.Side.SERVER); this.serverNetwork.setTap(new Tap()); //this.serverNetwork.dumper.addSchema(Demo.TestCap1); this.serverThread = runServer(this.serverNetwork); diff --git a/runtime/src/test/schema/test.capnp b/runtime-rpc/src/test/schema/test.capnp similarity index 100% rename from runtime/src/test/schema/test.capnp rename to runtime-rpc/src/test/schema/test.capnp diff --git a/runtime/src/main/java/org/capnproto/AnyPointer.java b/runtime/src/main/java/org/capnproto/AnyPointer.java index 0d5a18b..7acabbc 100644 --- a/runtime/src/main/java/org/capnproto/AnyPointer.java +++ b/runtime/src/main/java/org/capnproto/AnyPointer.java @@ -161,7 +161,7 @@ public final class AnyPointer { return this; } - Pipeline noop() { + public Pipeline noop() { return new Pipeline(this.hook, this.ops.clone()); } diff --git a/runtime/src/main/java/org/capnproto/PipelineOp.java b/runtime/src/main/java/org/capnproto/PipelineOp.java index e316068..11d32ca 100644 --- a/runtime/src/main/java/org/capnproto/PipelineOp.java +++ b/runtime/src/main/java/org/capnproto/PipelineOp.java @@ -25,38 +25,4 @@ final class PipelineOp { return new PipelineOp(Type.GET_POINTER_FIELD, pointerIndex); } - static void FromPipelineOps(PipelineOp[] ops, RpcProtocol.PromisedAnswer.Builder builder) { - var transforms = builder.initTransform(ops.length); - for (int ii = 0; ii < ops.length; ++ii) { - switch (ops[ii].type) { - case NOOP: - transforms.get(ii).setNoop(null); - break; - case GET_POINTER_FIELD: - transforms.get(ii).setGetPointerField(ops[ii].pointerIndex); - break; - } - } - } - - static PipelineOp[] ToPipelineOps(RpcProtocol.PromisedAnswer.Reader reader) { - var transforms = reader.getTransform(); - var ops = new PipelineOp[transforms.size()]; - for (int ii = 0; ii < ops.length; ++ii) { - var transform = transforms.get(ii); - switch (transform.which()) { - case NOOP: - ops[ii] = Noop(); // TODO null? - break; - case GET_POINTER_FIELD: - ops[ii] = PointerField(transform.getGetPointerField()); - break; - default: - // TODO improve error handling here - // Unsupported pipeline ops - return null; - } - } - return ops; - } } diff --git a/runtime/src/main/java/org/capnproto/RpcException.java b/runtime/src/main/java/org/capnproto/RpcException.java index cccc689..f748228 100644 --- a/runtime/src/main/java/org/capnproto/RpcException.java +++ b/runtime/src/main/java/org/capnproto/RpcException.java @@ -31,27 +31,4 @@ public final class RpcException extends java.lang.Exception { public static RpcException disconnected(String message) { return new RpcException(Type.DISCONNECTED, message); } - - static void fromException(Throwable exc, RpcProtocol.Exception.Builder builder) { - builder.setReason(exc.getMessage()); - builder.setType(RpcProtocol.Exception.Type.FAILED); - } - - static RpcException toException(RpcProtocol.Exception.Reader reader) { - var type = RpcException.Type.UNKNOWN; - - switch (reader.getType()) { - case UNIMPLEMENTED: - type = RpcException.Type.UNIMPLEMENTED; - break; - case FAILED: - type = RpcException.Type.FAILED; - break; - case DISCONNECTED: - case OVERLOADED: - default: - break; - } - return new RpcException(type, reader.getReason().toString()); - } } diff --git a/runtime/src/main/java/org/capnproto/RpcProtocol.java b/runtime/src/main/java/org/capnproto/RpcProtocol.java deleted file mode 100644 index 4e25b76..0000000 --- a/runtime/src/main/java/org/capnproto/RpcProtocol.java +++ /dev/null @@ -1,4304 +0,0 @@ -// Generated by Cap'n Proto compiler, DO NOT EDIT -// source: rpc.capnp - -package org.capnproto; - -public final class RpcProtocol { - public static class Message { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Message.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public Which which() { - switch(_getShortField(0)) { - case 0 : return Which.UNIMPLEMENTED; - case 1 : return Which.ABORT; - case 2 : return Which.CALL; - case 3 : return Which.RETURN; - case 4 : return Which.FINISH; - case 5 : return Which.RESOLVE; - case 6 : return Which.RELEASE; - case 7 : return Which.OBSOLETE_SAVE; - case 8 : return Which.BOOTSTRAP; - case 9 : return Which.OBSOLETE_DELETE; - case 10 : return Which.PROVIDE; - case 11 : return Which.ACCEPT; - case 12 : return Which.JOIN; - case 13 : return Which.DISEMBARGO; - default: return Which._NOT_IN_SCHEMA; - } - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean isUnimplemented() { - return which() == Message.Which.UNIMPLEMENTED; - } - public final org.capnproto.RpcProtocol.Message.Builder getUnimplemented() { - assert which() == Message.Which.UNIMPLEMENTED: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Message.factory, 0, null, 0); - } - public final void setUnimplemented(org.capnproto.RpcProtocol.Message.Reader value) { - _setShortField(0, (short)Message.Which.UNIMPLEMENTED.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Message.factory,0, value); - } - public final org.capnproto.RpcProtocol.Message.Builder initUnimplemented() { - _setShortField(0, (short)Message.Which.UNIMPLEMENTED.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Message.factory,0, 0); - } - public final boolean isAbort() { - return which() == Message.Which.ABORT; - } - public final org.capnproto.RpcProtocol.Exception.Builder getAbort() { - assert which() == Message.Which.ABORT: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Exception.factory, 0, null, 0); - } - public final void setAbort(org.capnproto.RpcProtocol.Exception.Reader value) { - _setShortField(0, (short)Message.Which.ABORT.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Exception.factory,0, value); - } - public final org.capnproto.RpcProtocol.Exception.Builder initAbort() { - _setShortField(0, (short)Message.Which.ABORT.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Exception.factory,0, 0); - } - public final boolean isCall() { - return which() == Message.Which.CALL; - } - public final org.capnproto.RpcProtocol.Call.Builder getCall() { - assert which() == Message.Which.CALL: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Call.factory, 0, null, 0); - } - public final void setCall(org.capnproto.RpcProtocol.Call.Reader value) { - _setShortField(0, (short)Message.Which.CALL.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Call.factory,0, value); - } - public final org.capnproto.RpcProtocol.Call.Builder initCall() { - _setShortField(0, (short)Message.Which.CALL.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Call.factory,0, 0); - } - public final boolean isReturn() { - return which() == Message.Which.RETURN; - } - public final org.capnproto.RpcProtocol.Return.Builder getReturn() { - assert which() == Message.Which.RETURN: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Return.factory, 0, null, 0); - } - public final void setReturn(org.capnproto.RpcProtocol.Return.Reader value) { - _setShortField(0, (short)Message.Which.RETURN.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Return.factory,0, value); - } - public final org.capnproto.RpcProtocol.Return.Builder initReturn() { - _setShortField(0, (short)Message.Which.RETURN.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Return.factory,0, 0); - } - public final boolean isFinish() { - return which() == Message.Which.FINISH; - } - public final org.capnproto.RpcProtocol.Finish.Builder getFinish() { - assert which() == Message.Which.FINISH: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Finish.factory, 0, null, 0); - } - public final void setFinish(org.capnproto.RpcProtocol.Finish.Reader value) { - _setShortField(0, (short)Message.Which.FINISH.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Finish.factory,0, value); - } - public final org.capnproto.RpcProtocol.Finish.Builder initFinish() { - _setShortField(0, (short)Message.Which.FINISH.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Finish.factory,0, 0); - } - public final boolean isResolve() { - return which() == Message.Which.RESOLVE; - } - public final org.capnproto.RpcProtocol.Resolve.Builder getResolve() { - assert which() == Message.Which.RESOLVE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Resolve.factory, 0, null, 0); - } - public final void setResolve(org.capnproto.RpcProtocol.Resolve.Reader value) { - _setShortField(0, (short)Message.Which.RESOLVE.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Resolve.factory,0, value); - } - public final org.capnproto.RpcProtocol.Resolve.Builder initResolve() { - _setShortField(0, (short)Message.Which.RESOLVE.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Resolve.factory,0, 0); - } - public final boolean isRelease() { - return which() == Message.Which.RELEASE; - } - public final org.capnproto.RpcProtocol.Release.Builder getRelease() { - assert which() == Message.Which.RELEASE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Release.factory, 0, null, 0); - } - public final void setRelease(org.capnproto.RpcProtocol.Release.Reader value) { - _setShortField(0, (short)Message.Which.RELEASE.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Release.factory,0, value); - } - public final org.capnproto.RpcProtocol.Release.Builder initRelease() { - _setShortField(0, (short)Message.Which.RELEASE.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Release.factory,0, 0); - } - public final boolean isObsoleteSave() { - return which() == Message.Which.OBSOLETE_SAVE; - } - public final boolean hasObsoleteSave() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Builder getObsoleteSave() { - assert which() == Message.Which.OBSOLETE_SAVE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public org.capnproto.AnyPointer.Builder initObsoleteSave() { - _setShortField(0, (short)Message.Which.OBSOLETE_SAVE.ordinal()); - return _initPointerField(org.capnproto.AnyPointer.factory, 0, 0); - } - public org.capnproto.AnyPointer.Builder initObsoleteSave(int size) { - _setShortField(0, (short)Message.Which.OBSOLETE_SAVE.ordinal()); - return _initPointerField(org.capnproto.AnyPointer.factory, 0, size); - } - - public final boolean isBootstrap() { - return which() == Message.Which.BOOTSTRAP; - } - public final org.capnproto.RpcProtocol.Bootstrap.Builder getBootstrap() { - assert which() == Message.Which.BOOTSTRAP: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Bootstrap.factory, 0, null, 0); - } - public final void setBootstrap(org.capnproto.RpcProtocol.Bootstrap.Reader value) { - _setShortField(0, (short)Message.Which.BOOTSTRAP.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Bootstrap.factory,0, value); - } - public final org.capnproto.RpcProtocol.Bootstrap.Builder initBootstrap() { - _setShortField(0, (short)Message.Which.BOOTSTRAP.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Bootstrap.factory,0, 0); - } - public final boolean isObsoleteDelete() { - return which() == Message.Which.OBSOLETE_DELETE; - } - public final boolean hasObsoleteDelete() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Builder getObsoleteDelete() { - assert which() == Message.Which.OBSOLETE_DELETE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public org.capnproto.AnyPointer.Builder initObsoleteDelete() { - _setShortField(0, (short)Message.Which.OBSOLETE_DELETE.ordinal()); - return _initPointerField(org.capnproto.AnyPointer.factory, 0, 0); - } - public org.capnproto.AnyPointer.Builder initObsoleteDelete(int size) { - _setShortField(0, (short)Message.Which.OBSOLETE_DELETE.ordinal()); - return _initPointerField(org.capnproto.AnyPointer.factory, 0, size); - } - - public final boolean isProvide() { - return which() == Message.Which.PROVIDE; - } - public final org.capnproto.RpcProtocol.Provide.Builder getProvide() { - assert which() == Message.Which.PROVIDE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Provide.factory, 0, null, 0); - } - public final void setProvide(org.capnproto.RpcProtocol.Provide.Reader value) { - _setShortField(0, (short)Message.Which.PROVIDE.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Provide.factory,0, value); - } - public final org.capnproto.RpcProtocol.Provide.Builder initProvide() { - _setShortField(0, (short)Message.Which.PROVIDE.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Provide.factory,0, 0); - } - public final boolean isAccept() { - return which() == Message.Which.ACCEPT; - } - public final org.capnproto.RpcProtocol.Accept.Builder getAccept() { - assert which() == Message.Which.ACCEPT: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Accept.factory, 0, null, 0); - } - public final void setAccept(org.capnproto.RpcProtocol.Accept.Reader value) { - _setShortField(0, (short)Message.Which.ACCEPT.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Accept.factory,0, value); - } - public final org.capnproto.RpcProtocol.Accept.Builder initAccept() { - _setShortField(0, (short)Message.Which.ACCEPT.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Accept.factory,0, 0); - } - public final boolean isJoin() { - return which() == Message.Which.JOIN; - } - public final org.capnproto.RpcProtocol.Join.Builder getJoin() { - assert which() == Message.Which.JOIN: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Join.factory, 0, null, 0); - } - public final void setJoin(org.capnproto.RpcProtocol.Join.Reader value) { - _setShortField(0, (short)Message.Which.JOIN.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Join.factory,0, value); - } - public final org.capnproto.RpcProtocol.Join.Builder initJoin() { - _setShortField(0, (short)Message.Which.JOIN.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Join.factory,0, 0); - } - public final boolean isDisembargo() { - return which() == Message.Which.DISEMBARGO; - } - public final org.capnproto.RpcProtocol.Disembargo.Builder getDisembargo() { - assert which() == Message.Which.DISEMBARGO: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Disembargo.factory, 0, null, 0); - } - public final void setDisembargo(org.capnproto.RpcProtocol.Disembargo.Reader value) { - _setShortField(0, (short)Message.Which.DISEMBARGO.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Disembargo.factory,0, value); - } - public final org.capnproto.RpcProtocol.Disembargo.Builder initDisembargo() { - _setShortField(0, (short)Message.Which.DISEMBARGO.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Disembargo.factory,0, 0); - } - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public Which which() { - switch(_getShortField(0)) { - case 0 : return Which.UNIMPLEMENTED; - case 1 : return Which.ABORT; - case 2 : return Which.CALL; - case 3 : return Which.RETURN; - case 4 : return Which.FINISH; - case 5 : return Which.RESOLVE; - case 6 : return Which.RELEASE; - case 7 : return Which.OBSOLETE_SAVE; - case 8 : return Which.BOOTSTRAP; - case 9 : return Which.OBSOLETE_DELETE; - case 10 : return Which.PROVIDE; - case 11 : return Which.ACCEPT; - case 12 : return Which.JOIN; - case 13 : return Which.DISEMBARGO; - default: return Which._NOT_IN_SCHEMA; - } - } - public final boolean isUnimplemented() { - return which() == Message.Which.UNIMPLEMENTED; - } - public boolean hasUnimplemented() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Message.Reader getUnimplemented() { - assert which() == Message.Which.UNIMPLEMENTED: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Message.factory,0,null, 0); - } - - public final boolean isAbort() { - return which() == Message.Which.ABORT; - } - public boolean hasAbort() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Exception.Reader getAbort() { - assert which() == Message.Which.ABORT: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Exception.factory,0,null, 0); - } - - public final boolean isCall() { - return which() == Message.Which.CALL; - } - public boolean hasCall() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Call.Reader getCall() { - assert which() == Message.Which.CALL: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Call.factory,0,null, 0); - } - - public final boolean isReturn() { - return which() == Message.Which.RETURN; - } - public boolean hasReturn() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Return.Reader getReturn() { - assert which() == Message.Which.RETURN: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Return.factory,0,null, 0); - } - - public final boolean isFinish() { - return which() == Message.Which.FINISH; - } - public boolean hasFinish() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Finish.Reader getFinish() { - assert which() == Message.Which.FINISH: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Finish.factory,0,null, 0); - } - - public final boolean isResolve() { - return which() == Message.Which.RESOLVE; - } - public boolean hasResolve() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Resolve.Reader getResolve() { - assert which() == Message.Which.RESOLVE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Resolve.factory,0,null, 0); - } - - public final boolean isRelease() { - return which() == Message.Which.RELEASE; - } - public boolean hasRelease() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Release.Reader getRelease() { - assert which() == Message.Which.RELEASE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Release.factory,0,null, 0); - } - - public final boolean isObsoleteSave() { - return which() == Message.Which.OBSOLETE_SAVE; - } - public boolean hasObsoleteSave() { - if (which() != Message.Which.OBSOLETE_SAVE) return false; - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Reader getObsoleteSave() { - assert which() == Message.Which.OBSOLETE_SAVE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public final boolean isBootstrap() { - return which() == Message.Which.BOOTSTRAP; - } - public boolean hasBootstrap() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Bootstrap.Reader getBootstrap() { - assert which() == Message.Which.BOOTSTRAP: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Bootstrap.factory,0,null, 0); - } - - public final boolean isObsoleteDelete() { - return which() == Message.Which.OBSOLETE_DELETE; - } - public boolean hasObsoleteDelete() { - if (which() != Message.Which.OBSOLETE_DELETE) return false; - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Reader getObsoleteDelete() { - assert which() == Message.Which.OBSOLETE_DELETE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public final boolean isProvide() { - return which() == Message.Which.PROVIDE; - } - public boolean hasProvide() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Provide.Reader getProvide() { - assert which() == Message.Which.PROVIDE: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Provide.factory,0,null, 0); - } - - public final boolean isAccept() { - return which() == Message.Which.ACCEPT; - } - public boolean hasAccept() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Accept.Reader getAccept() { - assert which() == Message.Which.ACCEPT: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Accept.factory,0,null, 0); - } - - public final boolean isJoin() { - return which() == Message.Which.JOIN; - } - public boolean hasJoin() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Join.Reader getJoin() { - assert which() == Message.Which.JOIN: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Join.factory,0,null, 0); - } - - public final boolean isDisembargo() { - return which() == Message.Which.DISEMBARGO; - } - public boolean hasDisembargo() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Disembargo.Reader getDisembargo() { - assert which() == Message.Which.DISEMBARGO: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Disembargo.factory,0,null, 0); - } - - } - - public enum Which { - UNIMPLEMENTED, - ABORT, - CALL, - RETURN, - FINISH, - RESOLVE, - RELEASE, - OBSOLETE_SAVE, - BOOTSTRAP, - OBSOLETE_DELETE, - PROVIDE, - ACCEPT, - JOIN, - DISEMBARGO, - _NOT_IN_SCHEMA, - } - } - - - public static class Bootstrap { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Bootstrap.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getQuestionId() { - return _getIntField(0); - } - public final void setQuestionId(int value) { - _setIntField(0, value); - } - - public final boolean hasDeprecatedObjectId() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Builder getDeprecatedObjectId() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public org.capnproto.AnyPointer.Builder initDeprecatedObjectId() { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, 0); - } - public org.capnproto.AnyPointer.Builder initDeprecatedObjectId(int size) { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, size); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getQuestionId() { - return _getIntField(0); - } - - public boolean hasDeprecatedObjectId() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Reader getDeprecatedObjectId() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - } - - } - - - public static class Call { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)3,(short)3); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Call.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getQuestionId() { - return _getIntField(0); - } - public final void setQuestionId(int value) { - _setIntField(0, value); - } - - public final org.capnproto.RpcProtocol.MessageTarget.Builder getTarget() { - return _getPointerField(org.capnproto.RpcProtocol.MessageTarget.factory, 0, null, 0); - } - public final void setTarget(org.capnproto.RpcProtocol.MessageTarget.Reader value) { - _setPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0, value); - } - public final org.capnproto.RpcProtocol.MessageTarget.Builder initTarget() { - return _initPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0, 0); - } - public final long getInterfaceId() { - return _getLongField(1); - } - public final void setInterfaceId(long value) { - _setLongField(1, value); - } - - public final short getMethodId() { - return _getShortField(2); - } - public final void setMethodId(short value) { - _setShortField(2, value); - } - - public final org.capnproto.RpcProtocol.Payload.Builder getParams() { - return _getPointerField(org.capnproto.RpcProtocol.Payload.factory, 1, null, 0); - } - public final void setParams(org.capnproto.RpcProtocol.Payload.Reader value) { - _setPointerField(org.capnproto.RpcProtocol.Payload.factory,1, value); - } - public final org.capnproto.RpcProtocol.Payload.Builder initParams() { - return _initPointerField(org.capnproto.RpcProtocol.Payload.factory,1, 0); - } - public final SendResultsTo.Builder getSendResultsTo() { - return new Call.SendResultsTo.Builder(segment, data, pointers, dataSize, pointerCount); - } - public final SendResultsTo.Builder initSendResultsTo() { - _setShortField(3,(short)0); - _clearPointerField(2); - return new Call.SendResultsTo.Builder(segment, data, pointers, dataSize, pointerCount); - } - - public final boolean getAllowThirdPartyTailCall() { - return _getBooleanField(128); - } - public final void setAllowThirdPartyTailCall(boolean value) { - _setBooleanField(128, value); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getQuestionId() { - return _getIntField(0); - } - - public boolean hasTarget() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.MessageTarget.Reader getTarget() { - return _getPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0,null, 0); - } - - public final long getInterfaceId() { - return _getLongField(1); - } - - public final short getMethodId() { - return _getShortField(2); - } - - public boolean hasParams() { - return !_pointerFieldIsNull(1); - } - public org.capnproto.RpcProtocol.Payload.Reader getParams() { - return _getPointerField(org.capnproto.RpcProtocol.Payload.factory,1,null, 0); - } - - public SendResultsTo.Reader getSendResultsTo() { - return new Call.SendResultsTo.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final boolean getAllowThirdPartyTailCall() { - return _getBooleanField(128); - } - - } - - public static class SendResultsTo { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)3,(short)3); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Call.SendResultsTo.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public Which which() { - switch(_getShortField(3)) { - case 0 : return Which.CALLER; - case 1 : return Which.YOURSELF; - case 2 : return Which.THIRD_PARTY; - default: return Which._NOT_IN_SCHEMA; - } - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean isCaller() { - return which() == Call.SendResultsTo.Which.CALLER; - } - public final org.capnproto.Void getCaller() { - assert which() == Call.SendResultsTo.Which.CALLER: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - public final void setCaller(org.capnproto.Void value) { - _setShortField(3, (short)Call.SendResultsTo.Which.CALLER.ordinal()); - } - - public final boolean isYourself() { - return which() == Call.SendResultsTo.Which.YOURSELF; - } - public final org.capnproto.Void getYourself() { - assert which() == Call.SendResultsTo.Which.YOURSELF: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - public final void setYourself(org.capnproto.Void value) { - _setShortField(3, (short)Call.SendResultsTo.Which.YOURSELF.ordinal()); - } - - public final boolean isThirdParty() { - return which() == Call.SendResultsTo.Which.THIRD_PARTY; - } - public final boolean hasThirdParty() { - return !_pointerFieldIsNull(2); - } - public org.capnproto.AnyPointer.Builder getThirdParty() { - assert which() == Call.SendResultsTo.Which.THIRD_PARTY: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.AnyPointer.factory, 2); - } - public org.capnproto.AnyPointer.Builder initThirdParty() { - _setShortField(3, (short)Call.SendResultsTo.Which.THIRD_PARTY.ordinal()); - return _initPointerField(org.capnproto.AnyPointer.factory, 2, 0); - } - public org.capnproto.AnyPointer.Builder initThirdParty(int size) { - _setShortField(3, (short)Call.SendResultsTo.Which.THIRD_PARTY.ordinal()); - return _initPointerField(org.capnproto.AnyPointer.factory, 2, size); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public Which which() { - switch(_getShortField(3)) { - case 0 : return Which.CALLER; - case 1 : return Which.YOURSELF; - case 2 : return Which.THIRD_PARTY; - default: return Which._NOT_IN_SCHEMA; - } - } - public final boolean isCaller() { - return which() == Call.SendResultsTo.Which.CALLER; - } - public final org.capnproto.Void getCaller() { - assert which() == Call.SendResultsTo.Which.CALLER: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - - public final boolean isYourself() { - return which() == Call.SendResultsTo.Which.YOURSELF; - } - public final org.capnproto.Void getYourself() { - assert which() == Call.SendResultsTo.Which.YOURSELF: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - - public final boolean isThirdParty() { - return which() == Call.SendResultsTo.Which.THIRD_PARTY; - } - public boolean hasThirdParty() { - if (which() != Call.SendResultsTo.Which.THIRD_PARTY) return false; - return !_pointerFieldIsNull(2); - } - public org.capnproto.AnyPointer.Reader getThirdParty() { - assert which() == Call.SendResultsTo.Which.THIRD_PARTY: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.AnyPointer.factory, 2); - } - } - - public enum Which { - CALLER, - YOURSELF, - THIRD_PARTY, - _NOT_IN_SCHEMA, - } - } - - - } - - - public static class Return { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)2,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Return.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public Which which() { - switch(_getShortField(3)) { - case 0 : return Which.RESULTS; - case 1 : return Which.EXCEPTION; - case 2 : return Which.CANCELED; - case 3 : return Which.RESULTS_SENT_ELSEWHERE; - case 4 : return Which.TAKE_FROM_OTHER_QUESTION; - case 5 : return Which.ACCEPT_FROM_THIRD_PARTY; - default: return Which._NOT_IN_SCHEMA; - } - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getAnswerId() { - return _getIntField(0); - } - public final void setAnswerId(int value) { - _setIntField(0, value); - } - - public final boolean getReleaseParamCaps() { - return _getBooleanField(32, (boolean)true); - } - public final void setReleaseParamCaps(boolean value) { - _setBooleanField(32, value, (boolean)true); - } - - public final boolean isResults() { - return which() == Return.Which.RESULTS; - } - public final org.capnproto.RpcProtocol.Payload.Builder getResults() { - assert which() == Return.Which.RESULTS: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Payload.factory, 0, null, 0); - } - public final void setResults(org.capnproto.RpcProtocol.Payload.Reader value) { - _setShortField(3, (short)Return.Which.RESULTS.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Payload.factory,0, value); - } - public final org.capnproto.RpcProtocol.Payload.Builder initResults() { - _setShortField(3, (short)Return.Which.RESULTS.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Payload.factory,0, 0); - } - public final boolean isException() { - return which() == Return.Which.EXCEPTION; - } - public final org.capnproto.RpcProtocol.Exception.Builder getException() { - assert which() == Return.Which.EXCEPTION: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Exception.factory, 0, null, 0); - } - public final void setException(org.capnproto.RpcProtocol.Exception.Reader value) { - _setShortField(3, (short)Return.Which.EXCEPTION.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Exception.factory,0, value); - } - public final org.capnproto.RpcProtocol.Exception.Builder initException() { - _setShortField(3, (short)Return.Which.EXCEPTION.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Exception.factory,0, 0); - } - public final boolean isCanceled() { - return which() == Return.Which.CANCELED; - } - public final org.capnproto.Void getCanceled() { - assert which() == Return.Which.CANCELED: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - public final void setCanceled(org.capnproto.Void value) { - _setShortField(3, (short)Return.Which.CANCELED.ordinal()); - } - - public final boolean isResultsSentElsewhere() { - return which() == Return.Which.RESULTS_SENT_ELSEWHERE; - } - public final org.capnproto.Void getResultsSentElsewhere() { - assert which() == Return.Which.RESULTS_SENT_ELSEWHERE: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - public final void setResultsSentElsewhere(org.capnproto.Void value) { - _setShortField(3, (short)Return.Which.RESULTS_SENT_ELSEWHERE.ordinal()); - } - - public final boolean isTakeFromOtherQuestion() { - return which() == Return.Which.TAKE_FROM_OTHER_QUESTION; - } - public final int getTakeFromOtherQuestion() { - assert which() == Return.Which.TAKE_FROM_OTHER_QUESTION: - "Must check which() before get()ing a union member."; - return _getIntField(2); - } - public final void setTakeFromOtherQuestion(int value) { - _setShortField(3, (short)Return.Which.TAKE_FROM_OTHER_QUESTION.ordinal()); - _setIntField(2, value); - } - - public final boolean isAcceptFromThirdParty() { - return which() == Return.Which.ACCEPT_FROM_THIRD_PARTY; - } - public final boolean hasAcceptFromThirdParty() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Builder getAcceptFromThirdParty() { - assert which() == Return.Which.ACCEPT_FROM_THIRD_PARTY: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public org.capnproto.AnyPointer.Builder initAcceptFromThirdParty() { - _setShortField(3, (short)Return.Which.ACCEPT_FROM_THIRD_PARTY.ordinal()); - return _initPointerField(org.capnproto.AnyPointer.factory, 0, 0); - } - public org.capnproto.AnyPointer.Builder initAcceptFromThirdParty(int size) { - _setShortField(3, (short)Return.Which.ACCEPT_FROM_THIRD_PARTY.ordinal()); - return _initPointerField(org.capnproto.AnyPointer.factory, 0, size); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public Which which() { - switch(_getShortField(3)) { - case 0 : return Which.RESULTS; - case 1 : return Which.EXCEPTION; - case 2 : return Which.CANCELED; - case 3 : return Which.RESULTS_SENT_ELSEWHERE; - case 4 : return Which.TAKE_FROM_OTHER_QUESTION; - case 5 : return Which.ACCEPT_FROM_THIRD_PARTY; - default: return Which._NOT_IN_SCHEMA; - } - } - public final int getAnswerId() { - return _getIntField(0); - } - - public final boolean getReleaseParamCaps() { - return _getBooleanField(32, (boolean)true); - } - - public final boolean isResults() { - return which() == Return.Which.RESULTS; - } - public boolean hasResults() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Payload.Reader getResults() { - assert which() == Return.Which.RESULTS: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Payload.factory,0,null, 0); - } - - public final boolean isException() { - return which() == Return.Which.EXCEPTION; - } - public boolean hasException() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Exception.Reader getException() { - assert which() == Return.Which.EXCEPTION: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Exception.factory,0,null, 0); - } - - public final boolean isCanceled() { - return which() == Return.Which.CANCELED; - } - public final org.capnproto.Void getCanceled() { - assert which() == Return.Which.CANCELED: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - - public final boolean isResultsSentElsewhere() { - return which() == Return.Which.RESULTS_SENT_ELSEWHERE; - } - public final org.capnproto.Void getResultsSentElsewhere() { - assert which() == Return.Which.RESULTS_SENT_ELSEWHERE: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - - public final boolean isTakeFromOtherQuestion() { - return which() == Return.Which.TAKE_FROM_OTHER_QUESTION; - } - public final int getTakeFromOtherQuestion() { - assert which() == Return.Which.TAKE_FROM_OTHER_QUESTION: - "Must check which() before get()ing a union member."; - return _getIntField(2); - } - - public final boolean isAcceptFromThirdParty() { - return which() == Return.Which.ACCEPT_FROM_THIRD_PARTY; - } - public boolean hasAcceptFromThirdParty() { - if (which() != Return.Which.ACCEPT_FROM_THIRD_PARTY) return false; - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Reader getAcceptFromThirdParty() { - assert which() == Return.Which.ACCEPT_FROM_THIRD_PARTY: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - } - - public enum Which { - RESULTS, - EXCEPTION, - CANCELED, - RESULTS_SENT_ELSEWHERE, - TAKE_FROM_OTHER_QUESTION, - ACCEPT_FROM_THIRD_PARTY, - _NOT_IN_SCHEMA, - } - } - - - public static class Finish { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)0); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Finish.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getQuestionId() { - return _getIntField(0); - } - public final void setQuestionId(int value) { - _setIntField(0, value); - } - - public final boolean getReleaseResultCaps() { - return _getBooleanField(32, (boolean)true); - } - public final void setReleaseResultCaps(boolean value) { - _setBooleanField(32, value, (boolean)true); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getQuestionId() { - return _getIntField(0); - } - - public final boolean getReleaseResultCaps() { - return _getBooleanField(32, (boolean)true); - } - - } - - } - - - public static class Resolve { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Resolve.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public Which which() { - switch(_getShortField(2)) { - case 0 : return Which.CAP; - case 1 : return Which.EXCEPTION; - default: return Which._NOT_IN_SCHEMA; - } - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getPromiseId() { - return _getIntField(0); - } - public final void setPromiseId(int value) { - _setIntField(0, value); - } - - public final boolean isCap() { - return which() == Resolve.Which.CAP; - } - public final org.capnproto.RpcProtocol.CapDescriptor.Builder getCap() { - assert which() == Resolve.Which.CAP: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.CapDescriptor.factory, 0, null, 0); - } - public final void setCap(org.capnproto.RpcProtocol.CapDescriptor.Reader value) { - _setShortField(2, (short)Resolve.Which.CAP.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.CapDescriptor.factory,0, value); - } - public final org.capnproto.RpcProtocol.CapDescriptor.Builder initCap() { - _setShortField(2, (short)Resolve.Which.CAP.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.CapDescriptor.factory,0, 0); - } - public final boolean isException() { - return which() == Resolve.Which.EXCEPTION; - } - public final org.capnproto.RpcProtocol.Exception.Builder getException() { - assert which() == Resolve.Which.EXCEPTION: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Exception.factory, 0, null, 0); - } - public final void setException(org.capnproto.RpcProtocol.Exception.Reader value) { - _setShortField(2, (short)Resolve.Which.EXCEPTION.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.Exception.factory,0, value); - } - public final org.capnproto.RpcProtocol.Exception.Builder initException() { - _setShortField(2, (short)Resolve.Which.EXCEPTION.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.Exception.factory,0, 0); - } - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public Which which() { - switch(_getShortField(2)) { - case 0 : return Which.CAP; - case 1 : return Which.EXCEPTION; - default: return Which._NOT_IN_SCHEMA; - } - } - public final int getPromiseId() { - return _getIntField(0); - } - - public final boolean isCap() { - return which() == Resolve.Which.CAP; - } - public boolean hasCap() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.CapDescriptor.Reader getCap() { - assert which() == Resolve.Which.CAP: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.CapDescriptor.factory,0,null, 0); - } - - public final boolean isException() { - return which() == Resolve.Which.EXCEPTION; - } - public boolean hasException() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.Exception.Reader getException() { - assert which() == Resolve.Which.EXCEPTION: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.Exception.factory,0,null, 0); - } - - } - - public enum Which { - CAP, - EXCEPTION, - _NOT_IN_SCHEMA, - } - } - - - public static class Release { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)0); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Release.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getId() { - return _getIntField(0); - } - public final void setId(int value) { - _setIntField(0, value); - } - - public final int getReferenceCount() { - return _getIntField(1); - } - public final void setReferenceCount(int value) { - _setIntField(1, value); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getId() { - return _getIntField(0); - } - - public final int getReferenceCount() { - return _getIntField(1); - } - - } - - } - - - public static class Disembargo { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Disembargo.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final org.capnproto.RpcProtocol.MessageTarget.Builder getTarget() { - return _getPointerField(org.capnproto.RpcProtocol.MessageTarget.factory, 0, null, 0); - } - public final void setTarget(org.capnproto.RpcProtocol.MessageTarget.Reader value) { - _setPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0, value); - } - public final org.capnproto.RpcProtocol.MessageTarget.Builder initTarget() { - return _initPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0, 0); - } - public final Context.Builder getContext() { - return new Disembargo.Context.Builder(segment, data, pointers, dataSize, pointerCount); - } - public final Context.Builder initContext() { - _setIntField(0,0); - _setShortField(2,(short)0); - return new Disembargo.Context.Builder(segment, data, pointers, dataSize, pointerCount); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public boolean hasTarget() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.MessageTarget.Reader getTarget() { - return _getPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0,null, 0); - } - - public Context.Reader getContext() { - return new Disembargo.Context.Reader(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - } - - public static class Context { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Disembargo.Context.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public Which which() { - switch(_getShortField(2)) { - case 0 : return Which.SENDER_LOOPBACK; - case 1 : return Which.RECEIVER_LOOPBACK; - case 2 : return Which.ACCEPT; - case 3 : return Which.PROVIDE; - default: return Which._NOT_IN_SCHEMA; - } - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean isSenderLoopback() { - return which() == Disembargo.Context.Which.SENDER_LOOPBACK; - } - public final int getSenderLoopback() { - assert which() == Disembargo.Context.Which.SENDER_LOOPBACK: - "Must check which() before get()ing a union member."; - return _getIntField(0); - } - public final void setSenderLoopback(int value) { - _setShortField(2, (short)Disembargo.Context.Which.SENDER_LOOPBACK.ordinal()); - _setIntField(0, value); - } - - public final boolean isReceiverLoopback() { - return which() == Disembargo.Context.Which.RECEIVER_LOOPBACK; - } - public final int getReceiverLoopback() { - assert which() == Disembargo.Context.Which.RECEIVER_LOOPBACK: - "Must check which() before get()ing a union member."; - return _getIntField(0); - } - public final void setReceiverLoopback(int value) { - _setShortField(2, (short)Disembargo.Context.Which.RECEIVER_LOOPBACK.ordinal()); - _setIntField(0, value); - } - - public final boolean isAccept() { - return which() == Disembargo.Context.Which.ACCEPT; - } - public final org.capnproto.Void getAccept() { - assert which() == Disembargo.Context.Which.ACCEPT: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - public final void setAccept(org.capnproto.Void value) { - _setShortField(2, (short)Disembargo.Context.Which.ACCEPT.ordinal()); - } - - public final boolean isProvide() { - return which() == Disembargo.Context.Which.PROVIDE; - } - public final int getProvide() { - assert which() == Disembargo.Context.Which.PROVIDE: - "Must check which() before get()ing a union member."; - return _getIntField(0); - } - public final void setProvide(int value) { - _setShortField(2, (short)Disembargo.Context.Which.PROVIDE.ordinal()); - _setIntField(0, value); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public Which which() { - switch(_getShortField(2)) { - case 0 : return Which.SENDER_LOOPBACK; - case 1 : return Which.RECEIVER_LOOPBACK; - case 2 : return Which.ACCEPT; - case 3 : return Which.PROVIDE; - default: return Which._NOT_IN_SCHEMA; - } - } - public final boolean isSenderLoopback() { - return which() == Disembargo.Context.Which.SENDER_LOOPBACK; - } - public final int getSenderLoopback() { - assert which() == Disembargo.Context.Which.SENDER_LOOPBACK: - "Must check which() before get()ing a union member."; - return _getIntField(0); - } - - public final boolean isReceiverLoopback() { - return which() == Disembargo.Context.Which.RECEIVER_LOOPBACK; - } - public final int getReceiverLoopback() { - assert which() == Disembargo.Context.Which.RECEIVER_LOOPBACK: - "Must check which() before get()ing a union member."; - return _getIntField(0); - } - - public final boolean isAccept() { - return which() == Disembargo.Context.Which.ACCEPT; - } - public final org.capnproto.Void getAccept() { - assert which() == Disembargo.Context.Which.ACCEPT: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - - public final boolean isProvide() { - return which() == Disembargo.Context.Which.PROVIDE; - } - public final int getProvide() { - assert which() == Disembargo.Context.Which.PROVIDE: - "Must check which() before get()ing a union member."; - return _getIntField(0); - } - - } - - public enum Which { - SENDER_LOOPBACK, - RECEIVER_LOOPBACK, - ACCEPT, - PROVIDE, - _NOT_IN_SCHEMA, - } - } - - - } - - - public static class Provide { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)2); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Provide.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getQuestionId() { - return _getIntField(0); - } - public final void setQuestionId(int value) { - _setIntField(0, value); - } - - public final org.capnproto.RpcProtocol.MessageTarget.Builder getTarget() { - return _getPointerField(org.capnproto.RpcProtocol.MessageTarget.factory, 0, null, 0); - } - public final void setTarget(org.capnproto.RpcProtocol.MessageTarget.Reader value) { - _setPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0, value); - } - public final org.capnproto.RpcProtocol.MessageTarget.Builder initTarget() { - return _initPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0, 0); - } - public final boolean hasRecipient() { - return !_pointerFieldIsNull(1); - } - public org.capnproto.AnyPointer.Builder getRecipient() { - return _getPointerField(org.capnproto.AnyPointer.factory, 1); - } - public org.capnproto.AnyPointer.Builder initRecipient() { - return _initPointerField(org.capnproto.AnyPointer.factory, 1, 0); - } - public org.capnproto.AnyPointer.Builder initRecipient(int size) { - return _initPointerField(org.capnproto.AnyPointer.factory, 1, size); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getQuestionId() { - return _getIntField(0); - } - - public boolean hasTarget() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.MessageTarget.Reader getTarget() { - return _getPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0,null, 0); - } - - public boolean hasRecipient() { - return !_pointerFieldIsNull(1); - } - public org.capnproto.AnyPointer.Reader getRecipient() { - return _getPointerField(org.capnproto.AnyPointer.factory, 1); - } - } - - } - - - public static class Accept { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Accept.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getQuestionId() { - return _getIntField(0); - } - public final void setQuestionId(int value) { - _setIntField(0, value); - } - - public final boolean hasProvision() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Builder getProvision() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public org.capnproto.AnyPointer.Builder initProvision() { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, 0); - } - public org.capnproto.AnyPointer.Builder initProvision(int size) { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, size); - } - - public final boolean getEmbargo() { - return _getBooleanField(32); - } - public final void setEmbargo(boolean value) { - _setBooleanField(32, value); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getQuestionId() { - return _getIntField(0); - } - - public boolean hasProvision() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Reader getProvision() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public final boolean getEmbargo() { - return _getBooleanField(32); - } - - } - - } - - - public static class Join { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)2); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Join.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getQuestionId() { - return _getIntField(0); - } - public final void setQuestionId(int value) { - _setIntField(0, value); - } - - public final org.capnproto.RpcProtocol.MessageTarget.Builder getTarget() { - return _getPointerField(org.capnproto.RpcProtocol.MessageTarget.factory, 0, null, 0); - } - public final void setTarget(org.capnproto.RpcProtocol.MessageTarget.Reader value) { - _setPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0, value); - } - public final org.capnproto.RpcProtocol.MessageTarget.Builder initTarget() { - return _initPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0, 0); - } - public final boolean hasKeyPart() { - return !_pointerFieldIsNull(1); - } - public org.capnproto.AnyPointer.Builder getKeyPart() { - return _getPointerField(org.capnproto.AnyPointer.factory, 1); - } - public org.capnproto.AnyPointer.Builder initKeyPart() { - return _initPointerField(org.capnproto.AnyPointer.factory, 1, 0); - } - public org.capnproto.AnyPointer.Builder initKeyPart(int size) { - return _initPointerField(org.capnproto.AnyPointer.factory, 1, size); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getQuestionId() { - return _getIntField(0); - } - - public boolean hasTarget() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.MessageTarget.Reader getTarget() { - return _getPointerField(org.capnproto.RpcProtocol.MessageTarget.factory,0,null, 0); - } - - public boolean hasKeyPart() { - return !_pointerFieldIsNull(1); - } - public org.capnproto.AnyPointer.Reader getKeyPart() { - return _getPointerField(org.capnproto.AnyPointer.factory, 1); - } - } - - } - - - public static class MessageTarget { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return MessageTarget.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public Which which() { - switch(_getShortField(2)) { - case 0 : return Which.IMPORTED_CAP; - case 1 : return Which.PROMISED_ANSWER; - default: return Which._NOT_IN_SCHEMA; - } - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean isImportedCap() { - return which() == MessageTarget.Which.IMPORTED_CAP; - } - public final int getImportedCap() { - assert which() == MessageTarget.Which.IMPORTED_CAP: - "Must check which() before get()ing a union member."; - return _getIntField(0); - } - public final void setImportedCap(int value) { - _setShortField(2, (short)MessageTarget.Which.IMPORTED_CAP.ordinal()); - _setIntField(0, value); - } - - public final boolean isPromisedAnswer() { - return which() == MessageTarget.Which.PROMISED_ANSWER; - } - public final org.capnproto.RpcProtocol.PromisedAnswer.Builder getPromisedAnswer() { - assert which() == MessageTarget.Which.PROMISED_ANSWER: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.PromisedAnswer.factory, 0, null, 0); - } - public final void setPromisedAnswer(org.capnproto.RpcProtocol.PromisedAnswer.Reader value) { - _setShortField(2, (short)MessageTarget.Which.PROMISED_ANSWER.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.PromisedAnswer.factory,0, value); - } - public final org.capnproto.RpcProtocol.PromisedAnswer.Builder initPromisedAnswer() { - _setShortField(2, (short)MessageTarget.Which.PROMISED_ANSWER.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.PromisedAnswer.factory,0, 0); - } - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public Which which() { - switch(_getShortField(2)) { - case 0 : return Which.IMPORTED_CAP; - case 1 : return Which.PROMISED_ANSWER; - default: return Which._NOT_IN_SCHEMA; - } - } - public final boolean isImportedCap() { - return which() == MessageTarget.Which.IMPORTED_CAP; - } - public final int getImportedCap() { - assert which() == MessageTarget.Which.IMPORTED_CAP: - "Must check which() before get()ing a union member."; - return _getIntField(0); - } - - public final boolean isPromisedAnswer() { - return which() == MessageTarget.Which.PROMISED_ANSWER; - } - public boolean hasPromisedAnswer() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.PromisedAnswer.Reader getPromisedAnswer() { - assert which() == MessageTarget.Which.PROMISED_ANSWER: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.PromisedAnswer.factory,0,null, 0); - } - - } - - public enum Which { - IMPORTED_CAP, - PROMISED_ANSWER, - _NOT_IN_SCHEMA, - } - } - - - public static class Payload { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)0,(short)2); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Payload.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean hasContent() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Builder getContent() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public org.capnproto.AnyPointer.Builder initContent() { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, 0); - } - public org.capnproto.AnyPointer.Builder initContent(int size) { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, size); - } - - public final boolean hasCapTable() { - return !_pointerFieldIsNull(1); - } - public final org.capnproto.StructList.Builder getCapTable() { - return _getPointerField(org.capnproto.RpcProtocol.CapDescriptor.listFactory, 1, null, 0); - } - public final void setCapTable(org.capnproto.StructList.Reader value) { - _setPointerField(org.capnproto.RpcProtocol.CapDescriptor.listFactory, 1, value); - } - public final org.capnproto.StructList.Builder initCapTable(int size) { - return _initPointerField(org.capnproto.RpcProtocol.CapDescriptor.listFactory, 1, size); - } - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public boolean hasContent() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Reader getContent() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public final boolean hasCapTable() { - return !_pointerFieldIsNull(1); - } - public final org.capnproto.StructList.Reader getCapTable() { - return _getPointerField(org.capnproto.RpcProtocol.CapDescriptor.listFactory, 1, null, 0); - } - - } - - } - - - public static class CapDescriptor { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return CapDescriptor.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public Which which() { - switch(_getShortField(0)) { - case 0 : return Which.NONE; - case 1 : return Which.SENDER_HOSTED; - case 2 : return Which.SENDER_PROMISE; - case 3 : return Which.RECEIVER_HOSTED; - case 4 : return Which.RECEIVER_ANSWER; - case 5 : return Which.THIRD_PARTY_HOSTED; - default: return Which._NOT_IN_SCHEMA; - } - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean isNone() { - return which() == CapDescriptor.Which.NONE; - } - public final org.capnproto.Void getNone() { - assert which() == CapDescriptor.Which.NONE: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - public final void setNone(org.capnproto.Void value) { - _setShortField(0, (short)CapDescriptor.Which.NONE.ordinal()); - } - - public final boolean isSenderHosted() { - return which() == CapDescriptor.Which.SENDER_HOSTED; - } - public final int getSenderHosted() { - assert which() == CapDescriptor.Which.SENDER_HOSTED: - "Must check which() before get()ing a union member."; - return _getIntField(1); - } - public final void setSenderHosted(int value) { - _setShortField(0, (short)CapDescriptor.Which.SENDER_HOSTED.ordinal()); - _setIntField(1, value); - } - - public final boolean isSenderPromise() { - return which() == CapDescriptor.Which.SENDER_PROMISE; - } - public final int getSenderPromise() { - assert which() == CapDescriptor.Which.SENDER_PROMISE: - "Must check which() before get()ing a union member."; - return _getIntField(1); - } - public final void setSenderPromise(int value) { - _setShortField(0, (short)CapDescriptor.Which.SENDER_PROMISE.ordinal()); - _setIntField(1, value); - } - - public final boolean isReceiverHosted() { - return which() == CapDescriptor.Which.RECEIVER_HOSTED; - } - public final int getReceiverHosted() { - assert which() == CapDescriptor.Which.RECEIVER_HOSTED: - "Must check which() before get()ing a union member."; - return _getIntField(1); - } - public final void setReceiverHosted(int value) { - _setShortField(0, (short)CapDescriptor.Which.RECEIVER_HOSTED.ordinal()); - _setIntField(1, value); - } - - public final boolean isReceiverAnswer() { - return which() == CapDescriptor.Which.RECEIVER_ANSWER; - } - public final org.capnproto.RpcProtocol.PromisedAnswer.Builder getReceiverAnswer() { - assert which() == CapDescriptor.Which.RECEIVER_ANSWER: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.PromisedAnswer.factory, 0, null, 0); - } - public final void setReceiverAnswer(org.capnproto.RpcProtocol.PromisedAnswer.Reader value) { - _setShortField(0, (short)CapDescriptor.Which.RECEIVER_ANSWER.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.PromisedAnswer.factory,0, value); - } - public final org.capnproto.RpcProtocol.PromisedAnswer.Builder initReceiverAnswer() { - _setShortField(0, (short)CapDescriptor.Which.RECEIVER_ANSWER.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.PromisedAnswer.factory,0, 0); - } - public final boolean isThirdPartyHosted() { - return which() == CapDescriptor.Which.THIRD_PARTY_HOSTED; - } - public final org.capnproto.RpcProtocol.ThirdPartyCapDescriptor.Builder getThirdPartyHosted() { - assert which() == CapDescriptor.Which.THIRD_PARTY_HOSTED: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.ThirdPartyCapDescriptor.factory, 0, null, 0); - } - public final void setThirdPartyHosted(org.capnproto.RpcProtocol.ThirdPartyCapDescriptor.Reader value) { - _setShortField(0, (short)CapDescriptor.Which.THIRD_PARTY_HOSTED.ordinal()); - _setPointerField(org.capnproto.RpcProtocol.ThirdPartyCapDescriptor.factory,0, value); - } - public final org.capnproto.RpcProtocol.ThirdPartyCapDescriptor.Builder initThirdPartyHosted() { - _setShortField(0, (short)CapDescriptor.Which.THIRD_PARTY_HOSTED.ordinal()); - return _initPointerField(org.capnproto.RpcProtocol.ThirdPartyCapDescriptor.factory,0, 0); - } - public final byte getAttachedFd() { - return _getByteField(2, (byte)-1); - } - public final void setAttachedFd(byte value) { - _setByteField(2, value, (byte)-1); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public Which which() { - switch(_getShortField(0)) { - case 0 : return Which.NONE; - case 1 : return Which.SENDER_HOSTED; - case 2 : return Which.SENDER_PROMISE; - case 3 : return Which.RECEIVER_HOSTED; - case 4 : return Which.RECEIVER_ANSWER; - case 5 : return Which.THIRD_PARTY_HOSTED; - default: return Which._NOT_IN_SCHEMA; - } - } - public final boolean isNone() { - return which() == CapDescriptor.Which.NONE; - } - public final org.capnproto.Void getNone() { - assert which() == CapDescriptor.Which.NONE: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - - public final boolean isSenderHosted() { - return which() == CapDescriptor.Which.SENDER_HOSTED; - } - public final int getSenderHosted() { - assert which() == CapDescriptor.Which.SENDER_HOSTED: - "Must check which() before get()ing a union member."; - return _getIntField(1); - } - - public final boolean isSenderPromise() { - return which() == CapDescriptor.Which.SENDER_PROMISE; - } - public final int getSenderPromise() { - assert which() == CapDescriptor.Which.SENDER_PROMISE: - "Must check which() before get()ing a union member."; - return _getIntField(1); - } - - public final boolean isReceiverHosted() { - return which() == CapDescriptor.Which.RECEIVER_HOSTED; - } - public final int getReceiverHosted() { - assert which() == CapDescriptor.Which.RECEIVER_HOSTED: - "Must check which() before get()ing a union member."; - return _getIntField(1); - } - - public final boolean isReceiverAnswer() { - return which() == CapDescriptor.Which.RECEIVER_ANSWER; - } - public boolean hasReceiverAnswer() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.PromisedAnswer.Reader getReceiverAnswer() { - assert which() == CapDescriptor.Which.RECEIVER_ANSWER: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.PromisedAnswer.factory,0,null, 0); - } - - public final boolean isThirdPartyHosted() { - return which() == CapDescriptor.Which.THIRD_PARTY_HOSTED; - } - public boolean hasThirdPartyHosted() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.RpcProtocol.ThirdPartyCapDescriptor.Reader getThirdPartyHosted() { - assert which() == CapDescriptor.Which.THIRD_PARTY_HOSTED: - "Must check which() before get()ing a union member."; - return _getPointerField(org.capnproto.RpcProtocol.ThirdPartyCapDescriptor.factory,0,null, 0); - } - - public final byte getAttachedFd() { - return _getByteField(2, (byte)-1); - } - - } - - public enum Which { - NONE, - SENDER_HOSTED, - SENDER_PROMISE, - RECEIVER_HOSTED, - RECEIVER_ANSWER, - THIRD_PARTY_HOSTED, - _NOT_IN_SCHEMA, - } - } - - - public static class PromisedAnswer { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return PromisedAnswer.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getQuestionId() { - return _getIntField(0); - } - public final void setQuestionId(int value) { - _setIntField(0, value); - } - - public final boolean hasTransform() { - return !_pointerFieldIsNull(0); - } - public final org.capnproto.StructList.Builder getTransform() { - return _getPointerField(org.capnproto.RpcProtocol.PromisedAnswer.Op.listFactory, 0, null, 0); - } - public final void setTransform(org.capnproto.StructList.Reader value) { - _setPointerField(org.capnproto.RpcProtocol.PromisedAnswer.Op.listFactory, 0, value); - } - public final org.capnproto.StructList.Builder initTransform(int size) { - return _initPointerField(org.capnproto.RpcProtocol.PromisedAnswer.Op.listFactory, 0, size); - } - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getQuestionId() { - return _getIntField(0); - } - - public final boolean hasTransform() { - return !_pointerFieldIsNull(0); - } - public final org.capnproto.StructList.Reader getTransform() { - return _getPointerField(org.capnproto.RpcProtocol.PromisedAnswer.Op.listFactory, 0, null, 0); - } - - } - - public static class Op { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)0); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return PromisedAnswer.Op.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public Which which() { - switch(_getShortField(0)) { - case 0 : return Which.NOOP; - case 1 : return Which.GET_POINTER_FIELD; - default: return Which._NOT_IN_SCHEMA; - } - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean isNoop() { - return which() == PromisedAnswer.Op.Which.NOOP; - } - public final org.capnproto.Void getNoop() { - assert which() == PromisedAnswer.Op.Which.NOOP: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - public final void setNoop(org.capnproto.Void value) { - _setShortField(0, (short)PromisedAnswer.Op.Which.NOOP.ordinal()); - } - - public final boolean isGetPointerField() { - return which() == PromisedAnswer.Op.Which.GET_POINTER_FIELD; - } - public final short getGetPointerField() { - assert which() == PromisedAnswer.Op.Which.GET_POINTER_FIELD: - "Must check which() before get()ing a union member."; - return _getShortField(1); - } - public final void setGetPointerField(short value) { - _setShortField(0, (short)PromisedAnswer.Op.Which.GET_POINTER_FIELD.ordinal()); - _setShortField(1, value); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public Which which() { - switch(_getShortField(0)) { - case 0 : return Which.NOOP; - case 1 : return Which.GET_POINTER_FIELD; - default: return Which._NOT_IN_SCHEMA; - } - } - public final boolean isNoop() { - return which() == PromisedAnswer.Op.Which.NOOP; - } - public final org.capnproto.Void getNoop() { - assert which() == PromisedAnswer.Op.Which.NOOP: - "Must check which() before get()ing a union member."; - return org.capnproto.Void.VOID; - } - - public final boolean isGetPointerField() { - return which() == PromisedAnswer.Op.Which.GET_POINTER_FIELD; - } - public final short getGetPointerField() { - assert which() == PromisedAnswer.Op.Which.GET_POINTER_FIELD: - "Must check which() before get()ing a union member."; - return _getShortField(1); - } - - } - - public enum Which { - NOOP, - GET_POINTER_FIELD, - _NOT_IN_SCHEMA, - } - } - - - } - - - public static class ThirdPartyCapDescriptor { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return ThirdPartyCapDescriptor.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean hasId() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Builder getId() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public org.capnproto.AnyPointer.Builder initId() { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, 0); - } - public org.capnproto.AnyPointer.Builder initId(int size) { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, size); - } - - public final int getVineId() { - return _getIntField(0); - } - public final void setVineId(int value) { - _setIntField(0, value); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public boolean hasId() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Reader getId() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public final int getVineId() { - return _getIntField(0); - } - - } - - } - - - public static class Exception { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return Exception.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final boolean hasReason() { - return !_pointerFieldIsNull(0); - } - public final org.capnproto.Text.Builder getReason() { - return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0); - } - public final void setReason(org.capnproto.Text.Reader value) { - _setPointerField(org.capnproto.Text.factory, 0, value); - } - public final void setReason(String value) { - _setPointerField(org.capnproto.Text.factory, 0, new org.capnproto.Text.Reader(value)); - } - public final org.capnproto.Text.Builder initReason(int size) { - return _initPointerField(org.capnproto.Text.factory, 0, size); - } - public final boolean getObsoleteIsCallersFault() { - return _getBooleanField(0); - } - public final void setObsoleteIsCallersFault(boolean value) { - _setBooleanField(0, value); - } - - public final short getObsoleteDurability() { - return _getShortField(1); - } - public final void setObsoleteDurability(short value) { - _setShortField(1, value); - } - - public final org.capnproto.RpcProtocol.Exception.Type getType() { - switch(_getShortField(2)) { - case 0 : return org.capnproto.RpcProtocol.Exception.Type.FAILED; - case 1 : return org.capnproto.RpcProtocol.Exception.Type.OVERLOADED; - case 2 : return org.capnproto.RpcProtocol.Exception.Type.DISCONNECTED; - case 3 : return org.capnproto.RpcProtocol.Exception.Type.UNIMPLEMENTED; - default: return org.capnproto.RpcProtocol.Exception.Type._NOT_IN_SCHEMA; - } - } - public final void setType(org.capnproto.RpcProtocol.Exception.Type value) { - _setShortField(2, (short)value.ordinal()); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public boolean hasReason() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.Text.Reader getReason() { - return _getPointerField(org.capnproto.Text.factory, 0, null, 0, 0); - } - - public final boolean getObsoleteIsCallersFault() { - return _getBooleanField(0); - } - - public final short getObsoleteDurability() { - return _getShortField(1); - } - - public final org.capnproto.RpcProtocol.Exception.Type getType() { - switch(_getShortField(2)) { - case 0 : return org.capnproto.RpcProtocol.Exception.Type.FAILED; - case 1 : return org.capnproto.RpcProtocol.Exception.Type.OVERLOADED; - case 2 : return org.capnproto.RpcProtocol.Exception.Type.DISCONNECTED; - case 3 : return org.capnproto.RpcProtocol.Exception.Type.UNIMPLEMENTED; - default: return org.capnproto.RpcProtocol.Exception.Type._NOT_IN_SCHEMA; - } - } - - } - - public enum Type { - FAILED, - OVERLOADED, - DISCONNECTED, - UNIMPLEMENTED, - _NOT_IN_SCHEMA, - } - - } - - - -public static final class Schemas { -public static final org.capnproto.SegmentReader b_91b79f1f808db032 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0032\u00b0\u008d\u0080\u001f\u009f\u00b7\u0091" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u000e\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00b2\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u0017\u0003\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u004d\u0065" + - "\u0073\u0073\u0061\u0067\u0065\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0038\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u00ff\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0079\u0001\u0000\u0000\u0072\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0078\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0084\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u00fe\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0081\u0001\u0000\u0000\u0032\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u007c\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0088\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0003\u0000\u00fd\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0085\u0001\u0000\u0000\u002a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0080\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u008c\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0004\u0000\u00fc\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0003\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0089\u0001\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0084\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0090\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0005\u0000\u00fb\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0004\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u008d\u0001\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0088\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0094\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0006\u0000\u00fa\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0005\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0091\u0001\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u008c\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0098\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0007\u0000\u00f9\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0006\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0095\u0001\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0090\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u009c\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0009\u0000\u00f8\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0099\u0001\u0000\u0000\u006a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0098\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00a4\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u00f7\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0008\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00a1\u0001\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00a0\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00ac\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\n\u0000\u00f6\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0009\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00a9\u0001\u0000\u0000\u007a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00a8\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00b4\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u000b\u0000\u00f5\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\n\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b1\u0001\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00ac\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00b8\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u000c\u0000\u00f4\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u000b\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b5\u0001\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b0\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00bc\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\r\u0000\u00f3\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u000c\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b9\u0001\u0000\u0000\u002a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b4\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00c0\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0008\u0000\u00f2\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\r\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00bd\u0001\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00bc\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00c8\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0075\u006e\u0069\u006d\u0070\u006c\u0065\u006d" + - "\u0065\u006e\u0074\u0065\u0064\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0032\u00b0\u008d\u0080\u001f\u009f\u00b7\u0091" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0061\u0062\u006f\u0072\u0074\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u001a\u0069\u00cf\u003a\u0006\u00b7\u0025\u00d6" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0063\u0061\u006c\u006c\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00d4\u004c\u009d\u0078\u00ce\u0053\u006a\u0083" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0074\u0075\u0072\u006e\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u003a\u0057\u00b3\u003d\u008d\u00b2\u0019\u009e" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0066\u0069\u006e\u0069\u0073\u0068\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0063\u000e\u00f8\u00c2\u00b2\u002e\u007d\u00d3" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0073\u006f\u006c\u0076\u0065\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006e\u0008\u0089\u00fa\u0055\u0096\u00c2\u00bb" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u006c\u0065\u0061\u0073\u0065\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0097\u0074\u00d0\u007d\r\u006c\u001a\u00ad" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006f\u0062\u0073\u006f\u006c\u0065\u0074\u0065" + - "\u0053\u0061\u0076\u0065\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0062\u006f\u006f\u0074\u0073\u0074\u0072\u0061" + - "\u0070\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c4\u006e\u0017\u0031\u0080\u00cf\u004c\u00e9" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006f\u0062\u0073\u006f\u006c\u0065\u0074\u0065" + - "\u0044\u0065\u006c\u0065\u0074\u0065\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0070\u0072\u006f\u0076\u0069\u0064\u0065\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u005a\u00ac\u00c1\u00fb\u006b\u0004\u006a\u009c" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0061\u0063\u0063\u0065\u0070\u0074\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0016\u0040\u0055\u0090\u0062\u00b5\u00c9\u00d4" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006a\u006f\u0069\u006e\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00af\u0001\u00e0\u0090\u0004\u0098\u00e1\u00fb" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0064\u0069\u0073\u0065\u006d\u0062\u0061\u0072" + - "\u0067\u006f\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0011\u0037\u00bd\u000f\u008b\u0036\u0064\u00f9" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_e94ccf8031176ec4 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u00c4\u006e\u0017\u0031\u0080\u00cf\u004c\u00e9" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00c2\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0042\u006f" + - "\u006f\u0074\u0073\u0074\u0072\u0061\u0070\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0028\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0034\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u009a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0034\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0040\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0071\u0075\u0065\u0073\u0074\u0069\u006f\u006e" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0064\u0065\u0070\u0072\u0065\u0063\u0061\u0074" + - "\u0065\u0064\u004f\u0062\u006a\u0065\u0063\u0074" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_836a53ce789d4cd4 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u00d4\u004c\u009d\u0078\u00ce\u0053\u006a\u0083" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0003\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0003\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u009a\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u008f\u0001\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0043\u0061" + - "\u006c\u006c\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u001c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b5\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b4\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00c0\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00bd\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b8\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00c4\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c1\u0000\u0000\u0000\u0062\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c0\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00cc\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0003\u0000\u0000\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0003\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c9\u0000\u0000\u0000\u004a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c8\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00d4\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0005\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0004\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00d1\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00cc\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00d8\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0006\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0099\u005f\u00ab\u001a\u00f6\u00b0\u00e8\u00da" + - "\u00d5\u0000\u0000\u0000\u0072\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0004\u0000\u0000\u0000\u0080\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0008\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c1\u0000\u0000\u0000\u00c2\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c4\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00d0\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0071\u0075\u0065\u0073\u0074\u0069\u006f\u006e" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0061\u0072\u0067\u0065\u0074\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c1\u00fb\u0013\u0058\u0054\u0014\u00bc\u0095" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0069\u006e\u0074\u0065\u0072\u0066\u0061\u0063" + - "\u0065\u0049\u0064\u0000\u0000\u0000\u0000\u0000" + - "\u0009\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0009\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006d\u0065\u0074\u0068\u006f\u0064\u0049\u0064" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0070\u0061\u0072\u0061\u006d\u0073\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u003b\u0074\u0096\u003d\"\u0061\u000e\u009a" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0073\u0065\u006e\u0064\u0052\u0065\u0073\u0075" + - "\u006c\u0074\u0073\u0054\u006f\u0000\u0000\u0000" + - "\u0061\u006c\u006c\u006f\u0077\u0054\u0068\u0069" + - "\u0072\u0064\u0050\u0061\u0072\u0074\u0079\u0054" + - "\u0061\u0069\u006c\u0043\u0061\u006c\u006c\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_dae8b0f61aab5f99 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0099\u005f\u00ab\u001a\u00f6\u00b0\u00e8\u00da" + - "\u0033\u0000\u0000\u0000\u0001\u0000\u0003\u0000" + - "\u00d4\u004c\u009d\u0078\u00ce\u0053\u006a\u0083" + - "\u0003\u0000\u0007\u0000\u0001\u0000\u0003\u0000" + - "\u0003\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\n\u0002\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u00af\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0043\u0061" + - "\u006c\u006c\u002e\u0073\u0065\u006e\u0064\u0052" + - "\u0065\u0073\u0075\u006c\u0074\u0073\u0054\u006f" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u000c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u00ff\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0005\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0045\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0040\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u004c\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u00fe\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0006\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0049\u0000\u0000\u0000\u004a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0048\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0054\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u00fd\u00ff\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0051\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0050\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\\\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0063\u0061\u006c\u006c\u0065\u0072\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0079\u006f\u0075\u0072\u0073\u0065\u006c\u0066" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0068\u0069\u0072\u0064\u0050\u0061\u0072" + - "\u0074\u0079\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_9e19b28d3db3573a = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u003a\u0057\u00b3\u003d\u008d\u00b2\u0019\u009e" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0002\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0006\u0000" + - "\u0003\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00aa\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u00c7\u0001\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0052\u0065" + - "\u0074\u0075\u0072\u006e\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0020\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00d1\u0000\u0000\u0000\u004a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00d0\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00dc\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0020\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00d9\u0000\u0000\u0000\u008a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00dc\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00e8\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u00ff\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00e5\u0000\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00e0\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00ec\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0003\u0000\u00fe\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0003\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00e9\u0000\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00e8\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00f4\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0004\u0000\u00fd\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0004\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00f1\u0000\u0000\u0000\u004a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00f0\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00fc\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0005\u0000\u00fc\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0005\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00f9\u0000\u0000\u0000\u00aa\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00fc\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0008\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0006\u0000\u00fb\u00ff\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0006\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0005\u0001\u0000\u0000\u00b2\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0014\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0007\u0000\u00fa\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0011\u0001\u0000\u0000\u00aa\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0014\u0001\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0020\u0001\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0061\u006e\u0073\u0077\u0065\u0072\u0049\u0064" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u006c\u0065\u0061\u0073\u0065\u0050" + - "\u0061\u0072\u0061\u006d\u0043\u0061\u0070\u0073" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0073\u0075\u006c\u0074\u0073\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u003b\u0074\u0096\u003d\"\u0061\u000e\u009a" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0065\u0078\u0063\u0065\u0070\u0074\u0069\u006f" + - "\u006e\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u001a\u0069\u00cf\u003a\u0006\u00b7\u0025\u00d6" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0063\u0061\u006e\u0063\u0065\u006c\u0065\u0064" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0073\u0075\u006c\u0074\u0073\u0053" + - "\u0065\u006e\u0074\u0045\u006c\u0073\u0065\u0077" + - "\u0068\u0065\u0072\u0065\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0061\u006b\u0065\u0046\u0072\u006f\u006d" + - "\u004f\u0074\u0068\u0065\u0072\u0051\u0075\u0065" + - "\u0073\u0074\u0069\u006f\u006e\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0061\u0063\u0063\u0065\u0070\u0074\u0046\u0072" + - "\u006f\u006d\u0054\u0068\u0069\u0072\u0064\u0050" + - "\u0061\u0072\u0074\u0079\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_d37d2eb2c2f80e63 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0063\u000e\u00f8\u00c2\u00b2\u002e\u007d\u00d3" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00aa\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0046\u0069" + - "\u006e\u0069\u0073\u0068\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0028\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0034\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0020\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0092\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0034\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0040\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0071\u0075\u0065\u0073\u0074\u0069\u006f\u006e" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u006c\u0065\u0061\u0073\u0065\u0052" + - "\u0065\u0073\u0075\u006c\u0074\u0043\u0061\u0070" + - "\u0073\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_bbc29655fa89086e = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u006e\u0008\u0089\u00fa\u0055\u0096\u00c2\u00bb" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0002\u0000" + - "\u0002\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00b2\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u00af\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0052\u0065" + - "\u0073\u006f\u006c\u0076\u0065\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u000c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0045\u0000\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0044\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0050\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u00ff\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004d\u0000\u0000\u0000\"\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0048\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0054\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u00fe\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0051\u0000\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0050\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\\\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0070\u0072\u006f\u006d\u0069\u0073\u0065\u0049" + - "\u0064\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0063\u0061\u0070\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b0\u00b8\u0086\u000b\u00c4\u00dd\u0023\u0085" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0065\u0078\u0063\u0065\u0070\u0074\u0069\u006f" + - "\u006e\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u001a\u0069\u00cf\u003a\u0006\u00b7\u0025\u00d6" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_ad1a6c0d7dd07497 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0097\u0074\u00d0\u007d\r\u006c\u001a\u00ad" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00b2\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0052\u0065" + - "\u006c\u0065\u0061\u0073\u0065\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u001a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0024\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0030\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u007a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002c\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0038\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0069\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0066\u0065\u0072\u0065\u006e\u0063" + - "\u0065\u0043\u006f\u0075\u006e\u0074\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_f964368b0fbd3711 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0011\u0037\u00bd\u000f\u008b\u0036\u0064\u00f9" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00ca\u0001\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0044\u0069" + - "\u0073\u0065\u006d\u0062\u0061\u0072\u0067\u006f" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0024\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0030\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004d\u00dd\u005b\u0065\u00df\u00b4\u0062\u00d5" + - "\u002d\u0000\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0061\u0072\u0067\u0065\u0074\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c1\u00fb\u0013\u0058\u0054\u0014\u00bc\u0095" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0063\u006f\u006e\u0074\u0065\u0078\u0074\u0000" + ""); -public static final org.capnproto.SegmentReader b_d562b4df655bdd4d = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u004d\u00dd\u005b\u0065\u00df\u00b4\u0062\u00d5" + - "\u0039\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0011\u0037\u00bd\u000f\u008b\u0036\u0064\u00f9" + - "\u0001\u0000\u0007\u0000\u0001\u0000\u0004\u0000" + - "\u0002\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\n\u0002\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u00e7\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0044\u0069" + - "\u0073\u0065\u006d\u0062\u0061\u0072\u0067\u006f" + - "\u002e\u0063\u006f\u006e\u0074\u0065\u0078\u0074" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u00ff\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0061\u0000\u0000\u0000\u007a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0060\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u006c\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u00fe\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0069\u0000\u0000\u0000\u008a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006c\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0078\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u00fd\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0003\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0075\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0070\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u007c\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0003\u0000\u00fc\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0004\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0079\u0000\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0080\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0073\u0065\u006e\u0064\u0065\u0072\u004c\u006f" + - "\u006f\u0070\u0062\u0061\u0063\u006b\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0063\u0065\u0069\u0076\u0065\u0072" + - "\u004c\u006f\u006f\u0070\u0062\u0061\u0063\u006b" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0061\u0063\u0063\u0065\u0070\u0074\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0070\u0072\u006f\u0076\u0069\u0064\u0065\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_9c6a046bfbc1ac5a = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u005a\u00ac\u00c1\u00fb\u006b\u0004\u006a\u009c" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0002\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00b2\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u00af\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0050\u0072" + - "\u006f\u0076\u0069\u0064\u0065\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u000c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0045\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0044\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0050\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004d\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0048\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0054\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0051\u0000\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0050\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\\\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0071\u0075\u0065\u0073\u0074\u0069\u006f\u006e" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0061\u0072\u0067\u0065\u0074\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c1\u00fb\u0013\u0058\u0054\u0014\u00bc\u0095" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0063\u0069\u0070\u0069\u0065\u006e" + - "\u0074\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_d4c9b56290554016 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0016\u0040\u0055\u0090\u0062\u00b5\u00c9\u00d4" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00aa\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u00af\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0041\u0063" + - "\u0063\u0065\u0070\u0074\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u000c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0045\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0044\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0050\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004d\u0000\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004c\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0058\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u0000\u0000\u0020\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0055\u0000\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0050\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\\\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0071\u0075\u0065\u0073\u0074\u0069\u006f\u006e" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0070\u0072\u006f\u0076\u0069\u0073\u0069\u006f" + - "\u006e\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0065\u006d\u0062\u0061\u0072\u0067\u006f\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_fbe1980490e001af = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u00af\u0001\u00e0\u0090\u0004\u0098\u00e1\u00fb" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0002\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u009a\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u00af\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u004a\u006f" + - "\u0069\u006e\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u000c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0045\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0044\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0050\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004d\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0048\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0054\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0051\u0000\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004c\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0058\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0071\u0075\u0065\u0073\u0074\u0069\u006f\u006e" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0061\u0072\u0067\u0065\u0074\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c1\u00fb\u0013\u0058\u0054\u0014\u00bc\u0095" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006b\u0065\u0079\u0050\u0061\u0072\u0074\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_95bc14545813fbc1 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u00c1\u00fb\u0013\u0058\u0054\u0014\u00bc\u0095" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0002\u0000" + - "\u0002\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00e2\u0001\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u004d\u0065" + - "\u0073\u0073\u0061\u0067\u0065\u0054\u0061\u0072" + - "\u0067\u0065\u0074\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u00ff\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u0062\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0028\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0034\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u00fe\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u007a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0030\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u003c\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0069\u006d\u0070\u006f\u0072\u0074\u0065\u0064" + - "\u0043\u0061\u0070\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0070\u0072\u006f\u006d\u0069\u0073\u0065\u0064" + - "\u0041\u006e\u0073\u0077\u0065\u0072\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00a0\u001c\u006f\u00cd\u00d6\u00b1\u0000\u00d8" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_9a0e61223d96743b = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u003b\u0074\u0096\u003d\"\u0061\u000e\u009a" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0002\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00b2\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0050\u0061" + - "\u0079\u006c\u006f\u0061\u0064\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0024\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0030\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u004a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002c\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0048\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0063\u006f\u006e\u0074\u0065\u006e\u0074\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0063\u0061\u0070\u0054\u0061\u0062\u006c\u0065" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u000e\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b0\u00b8\u0086\u000b\u00c4\u00dd\u0023\u0085" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u000e\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_8523ddc40b86b8b0 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u00b0\u00b8\u0086\u000b\u00c4\u00dd\u0023\u0085" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0006\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00e2\u0001\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u008f\u0001\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0043\u0061" + - "\u0070\u0044\u0065\u0073\u0063\u0072\u0069\u0070" + - "\u0074\u006f\u0072\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u001c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u00ff\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b5\u0000\u0000\u0000\u002a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b0\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00bc\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u00fe\u00ff\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b9\u0000\u0000\u0000\u006a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00b8\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00c4\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u00fd\u00ff\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c1\u0000\u0000\u0000\u0072\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c0\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00cc\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0003\u0000\u00fc\u00ff\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0003\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c9\u0000\u0000\u0000\u007a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00c8\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00d4\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0004\u0000\u00fb\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0004\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00d1\u0000\u0000\u0000\u007a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00d0\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00dc\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0005\u0000\u00fa\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0005\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00d9\u0000\u0000\u0000\u008a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00dc\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00e8\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0006\u0000\u0000\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0006\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00e5\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00e4\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u00f0\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u006e\u006f\u006e\u0065\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0073\u0065\u006e\u0064\u0065\u0072\u0048\u006f" + - "\u0073\u0074\u0065\u0064\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0073\u0065\u006e\u0064\u0065\u0072\u0050\u0072" + - "\u006f\u006d\u0069\u0073\u0065\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0063\u0065\u0069\u0076\u0065\u0072" + - "\u0048\u006f\u0073\u0074\u0065\u0064\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0065\u0063\u0065\u0069\u0076\u0065\u0072" + - "\u0041\u006e\u0073\u0077\u0065\u0072\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u00a0\u001c\u006f\u00cd\u00d6\u00b1\u0000\u00d8" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0068\u0069\u0072\u0064\u0050\u0061\u0072" + - "\u0074\u0079\u0048\u006f\u0073\u0074\u0065\u0064" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u007d\u0002\u00f0\u00e1\u00fd\u0007\u0070\u00d3" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0061\u0074\u0074\u0061\u0063\u0068\u0065\u0064" + - "\u0046\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0006\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0006\u0000\u00ff\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_d800b1d6cd6f1ca0 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u00a0\u001c\u006f\u00cd\u00d6\u00b1\u0000\u00d8" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00ea\u0001\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0017\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0039\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0050\u0072" + - "\u006f\u006d\u0069\u0073\u0065\u0064\u0041\u006e" + - "\u0073\u0077\u0065\u0072\u0000\u0000\u0000\u0000" + - "\u0004\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0081\u0090\u0056\u0015\u0044\u0094\u0016\u00f3" + - "\u0001\u0000\u0000\u0000\u001a\u0000\u0000\u0000" + - "\u004f\u0070\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0028\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0034\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0030\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u004c\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0071\u0075\u0065\u0073\u0074\u0069\u006f\u006e" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0072\u0061\u006e\u0073\u0066\u006f\u0072" + - "\u006d\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u000e\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0010\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0081\u0090\u0056\u0015\u0044\u0094\u0016\u00f3" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u000e\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_f316944415569081 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0081\u0090\u0056\u0015\u0044\u0094\u0016\u00f3" + - "\u003d\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u00a0\u001c\u006f\u00cd\u00d6\u00b1\u0000\u00d8" + - "\u0000\u0000\u0007\u0000\u0000\u0000\u0002\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u0002\u0002\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0050\u0072" + - "\u006f\u006d\u0069\u0073\u0065\u0064\u0041\u006e" + - "\u0073\u0077\u0065\u0072\u002e\u004f\u0070\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u00ff\u00ff\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u002a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0024\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0030\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u00fe\u00ff\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0082\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002c\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0038\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u006e\u006f\u006f\u0070\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0067\u0065\u0074\u0050\u006f\u0069\u006e\u0074" + - "\u0065\u0072\u0046\u0069\u0065\u006c\u0064\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_d37007fde1f0027d = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u007d\u0002\u00f0\u00e1\u00fd\u0007\u0070\u00d3" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u0032\u0002\u0000\u0000" + - "\u0035\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0077\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0054\u0068" + - "\u0069\u0072\u0064\u0050\u0061\u0072\u0074\u0079" + - "\u0043\u0061\u0070\u0044\u0065\u0073\u0063\u0072" + - "\u0069\u0070\u0074\u006f\u0072\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u001a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0024\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0030\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0028\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0034\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0069\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0076\u0069\u006e\u0065\u0049\u0064\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_d625b7063acf691a = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u001a\u0069\u00cf\u003a\u0006\u00b7\u0025\u00d6" + - "\u002e\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0050\u00a2\u0052\u0025\u001b\u0098\u0012\u00b3" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00c2\u0001\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0017\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0035\u0000\u0000\u0000\u00e7\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0045\u0078" + - "\u0063\u0065\u0070\u0074\u0069\u006f\u006e\u0000" + - "\u0004\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0058\u00bd\u004c\u003f\u00e2\u0096\u008c\u00b2" + - "\u0001\u0000\u0000\u0000\u002a\u0000\u0000\u0000" + - "\u0054\u0079\u0070\u0065\u0000\u0000\u0000\u0000" + - "\u0010\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0061\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\\\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0068\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0065\u0000\u0000\u0000\u00ba\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0068\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0074\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0003\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0071\u0000\u0000\u0000\u009a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0080\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0003\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u007d\u0000\u0000\u0000\u002a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0078\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0084\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0072\u0065\u0061\u0073\u006f\u006e\u0000\u0000" + - "\u000c\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u000c\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006f\u0062\u0073\u006f\u006c\u0065\u0074\u0065" + - "\u0049\u0073\u0043\u0061\u006c\u006c\u0065\u0072" + - "\u0073\u0046\u0061\u0075\u006c\u0074\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u006f\u0062\u0073\u006f\u006c\u0065\u0074\u0065" + - "\u0044\u0075\u0072\u0061\u0062\u0069\u006c\u0069" + - "\u0074\u0079\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0074\u0079\u0070\u0065\u0000\u0000\u0000\u0000" + - "\u000f\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0058\u00bd\u004c\u003f\u00e2\u0096\u008c\u00b2" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u000f\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_b28c96e23f4cbd58 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0058\u00bd\u004c\u003f\u00e2\u0096\u008c\u00b2" + - "\u0038\u0000\u0000\u0000\u0002\u0000\u0000\u0000" + - "\u001a\u0069\u00cf\u003a\u0006\u00b7\u0025\u00d6" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00ea\u0001\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0067\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002e" + - "\u0063\u0061\u0070\u006e\u0070\u003a\u0045\u0078" + - "\u0063\u0065\u0070\u0074\u0069\u006f\u006e\u002e" + - "\u0054\u0079\u0070\u0065\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0010\u0000\u0000\u0000\u0001\u0000\u0002\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0029\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0021\u0000\u0000\u0000\u005a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0002\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u001d\u0000\u0000\u0000\u006a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0003\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0019\u0000\u0000\u0000\u0072\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0066\u0061\u0069\u006c\u0065\u0064\u0000\u0000" + - "\u006f\u0076\u0065\u0072\u006c\u006f\u0061\u0064" + - "\u0065\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0064\u0069\u0073\u0063\u006f\u006e\u006e\u0065" + - "\u0063\u0074\u0065\u0064\u0000\u0000\u0000\u0000" + - "\u0075\u006e\u0069\u006d\u0070\u006c\u0065\u006d" + - "\u0065\u006e\u0074\u0065\u0064\u0000\u0000\u0000" + ""); -} -} - diff --git a/runtime/src/main/java/org/capnproto/RpcTwoPartyProtocol.java b/runtime/src/main/java/org/capnproto/RpcTwoPartyProtocol.java deleted file mode 100644 index 05bdbd1..0000000 --- a/runtime/src/main/java/org/capnproto/RpcTwoPartyProtocol.java +++ /dev/null @@ -1,662 +0,0 @@ -// Generated by Cap'n Proto compiler, DO NOT EDIT -// source: rpc-twoparty.capnp - -package org.capnproto; - -public final class RpcTwoPartyProtocol { - public enum Side { - SERVER, - CLIENT, - _NOT_IN_SCHEMA, - } - - public static class VatId { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)0); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return VatId.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final org.capnproto.RpcTwoPartyProtocol.Side getSide() { - switch(_getShortField(0)) { - case 0 : return org.capnproto.RpcTwoPartyProtocol.Side.SERVER; - case 1 : return org.capnproto.RpcTwoPartyProtocol.Side.CLIENT; - default: return org.capnproto.RpcTwoPartyProtocol.Side._NOT_IN_SCHEMA; - } - } - public final void setSide(org.capnproto.RpcTwoPartyProtocol.Side value) { - _setShortField(0, (short)value.ordinal()); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final org.capnproto.RpcTwoPartyProtocol.Side getSide() { - switch(_getShortField(0)) { - case 0 : return org.capnproto.RpcTwoPartyProtocol.Side.SERVER; - case 1 : return org.capnproto.RpcTwoPartyProtocol.Side.CLIENT; - default: return org.capnproto.RpcTwoPartyProtocol.Side._NOT_IN_SCHEMA; - } - } - - } - - } - - - public static class ProvisionId { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)0); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return ProvisionId.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getJoinId() { - return _getIntField(0); - } - public final void setJoinId(int value) { - _setIntField(0, value); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getJoinId() { - return _getIntField(0); - } - - } - - } - - - public static class RecipientId { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)0,(short)0); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return RecipientId.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - } - - } - - - public static class ThirdPartyCapId { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)0,(short)0); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return ThirdPartyCapId.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - } - - } - - - public static class JoinKeyPart { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)0); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return JoinKeyPart.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getJoinId() { - return _getIntField(0); - } - public final void setJoinId(int value) { - _setIntField(0, value); - } - - public final short getPartCount() { - return _getShortField(2); - } - public final void setPartCount(short value) { - _setShortField(2, value); - } - - public final short getPartNum() { - return _getShortField(3); - } - public final void setPartNum(short value) { - _setShortField(3, value); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getJoinId() { - return _getIntField(0); - } - - public final short getPartCount() { - return _getShortField(2); - } - - public final short getPartNum() { - return _getShortField(3); - } - - } - - } - - - public static class JoinResult { - public static final org.capnproto.StructSize STRUCT_SIZE = new org.capnproto.StructSize((short)1,(short)1); - public static final class Factory extends org.capnproto.StructFactory { - public Factory() { - } - public final Reader constructReader(org.capnproto.SegmentReader segment, int data,int pointers, int dataSize, short pointerCount, int nestingLimit) { - return new Reader(segment,data,pointers,dataSize,pointerCount,nestingLimit); - } - public final Builder constructBuilder(org.capnproto.SegmentBuilder segment, int data,int pointers, int dataSize, short pointerCount) { - return new Builder(segment, data, pointers, dataSize, pointerCount); - } - public final org.capnproto.StructSize structSize() { - return JoinResult.STRUCT_SIZE; - } - public final Reader asReader(Builder builder) { - return builder.asReader(); - } - } - public static final Factory factory = new Factory(); - public static final org.capnproto.StructList.Factory listFactory = - new org.capnproto.StructList.Factory(factory); - public static final class Builder extends org.capnproto.StructBuilder { - Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,int dataSize, short pointerCount){ - super(segment, data, pointers, dataSize, pointerCount); - } - public final Reader asReader() { - return new Reader(segment, data, pointers, dataSize, pointerCount, 0x7fffffff); - } - public final int getJoinId() { - return _getIntField(0); - } - public final void setJoinId(int value) { - _setIntField(0, value); - } - - public final boolean getSucceeded() { - return _getBooleanField(32); - } - public final void setSucceeded(boolean value) { - _setBooleanField(32, value); - } - - public final boolean hasCap() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Builder getCap() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - public org.capnproto.AnyPointer.Builder initCap() { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, 0); - } - public org.capnproto.AnyPointer.Builder initCap(int size) { - return _initPointerField(org.capnproto.AnyPointer.factory, 0, size); - } - - } - - public static final class Reader extends org.capnproto.StructReader { - Reader(org.capnproto.SegmentReader segment, int data, int pointers,int dataSize, short pointerCount, int nestingLimit){ - super(segment, data, pointers, dataSize, pointerCount, nestingLimit); - } - - public final int getJoinId() { - return _getIntField(0); - } - - public final boolean getSucceeded() { - return _getBooleanField(32); - } - - public boolean hasCap() { - return !_pointerFieldIsNull(0); - } - public org.capnproto.AnyPointer.Reader getCap() { - return _getPointerField(org.capnproto.AnyPointer.factory, 0); - } - } - - } - - - -public static final class Schemas { -public static final org.capnproto.SegmentReader b_9fd69ebc87b9719c = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u009c\u0071\u00b9\u0087\u00bc\u009e\u00d6\u009f" + - "\u0037\u0000\u0000\u0000\u0002\u0000\u0000\u0000" + - "\u00a1\u00f2\u00da\\\u0088\u00c7\u0084\u00a1" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00e2\u0001\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u0037\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002d" + - "\u0074\u0077\u006f\u0070\u0061\u0072\u0074\u0079" + - "\u002e\u0063\u0061\u0070\u006e\u0070\u003a\u0053" + - "\u0069\u0064\u0065\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0008\u0000\u0000\u0000\u0001\u0000\u0002\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0011\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0009\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0073\u0065\u0072\u0076\u0065\u0072\u0000\u0000" + - "\u0063\u006c\u0069\u0065\u006e\u0074\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_d20b909fee733a8e = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u008e\u003a\u0073\u00ee\u009f\u0090\u000b\u00d2" + - "\u0037\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u00a1\u00f2\u00da\\\u0088\u00c7\u0084\u00a1" + - "\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u00ea\u0001\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u002d\u0000\u0000\u0000\u003f\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002d" + - "\u0074\u0077\u006f\u0070\u0061\u0072\u0074\u0079" + - "\u002e\u0063\u0061\u0070\u006e\u0070\u003a\u0056" + - "\u0061\u0074\u0049\u0064\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0004\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\r\u0000\u0000\u0000\u002a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0014\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0073\u0069\u0064\u0065\u0000\u0000\u0000\u0000" + - "\u000f\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u009c\u0071\u00b9\u0087\u00bc\u009e\u00d6\u009f" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u000f\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_b88d09a9c5f39817 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0017\u0098\u00f3\u00c5\u00a9\u0009\u008d\u00b8" + - "\u0037\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u00a1\u00f2\u00da\\\u0088\u00c7\u0084\u00a1" + - "\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u001a\u0002\u0000\u0000" + - "\u0035\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u003f\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002d" + - "\u0074\u0077\u006f\u0070\u0061\u0072\u0074\u0079" + - "\u002e\u0063\u0061\u0070\u006e\u0070\u003a\u0050" + - "\u0072\u006f\u0076\u0069\u0073\u0069\u006f\u006e" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u0004\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\r\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0014\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u006a\u006f\u0069\u006e\u0049\u0064\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_89f389b6fd4082c1 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u00c1\u0082\u0040\u00fd\u00b6\u0089\u00f3\u0089" + - "\u0037\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u00a1\u00f2\u00da\\\u0088\u00c7\u0084\u00a1" + - "\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u001a\u0002\u0000\u0000" + - "\u0035\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002d" + - "\u0074\u0077\u006f\u0070\u0061\u0072\u0074\u0079" + - "\u002e\u0063\u0061\u0070\u006e\u0070\u003a\u0052" + - "\u0065\u0063\u0069\u0070\u0069\u0065\u006e\u0074" + - "\u0049\u0064\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + ""); -public static final org.capnproto.SegmentReader b_b47f4979672cb59d = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u009d\u00b5\u002c\u0067\u0079\u0049\u007f\u00b4" + - "\u0037\u0000\u0000\u0000\u0001\u0000\u0000\u0000" + - "\u00a1\u00f2\u00da\\\u0088\u00c7\u0084\u00a1" + - "\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u003a\u0002\u0000\u0000" + - "\u0035\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002d" + - "\u0074\u0077\u006f\u0070\u0061\u0072\u0074\u0079" + - "\u002e\u0063\u0061\u0070\u006e\u0070\u003a\u0054" + - "\u0068\u0069\u0072\u0064\u0050\u0061\u0072\u0074" + - "\u0079\u0043\u0061\u0070\u0049\u0064\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + ""); -public static final org.capnproto.SegmentReader b_95b29059097fca83 = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u0083\u00ca\u007f\u0009\u0059\u0090\u00b2\u0095" + - "\u0037\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u00a1\u00f2\u00da\\\u0088\u00c7\u0084\u00a1" + - "\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u001a\u0002\u0000\u0000" + - "\u0035\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u00af\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002d" + - "\u0074\u0077\u006f\u0070\u0061\u0072\u0074\u0079" + - "\u002e\u0063\u0061\u0070\u006e\u0070\u003a\u004a" + - "\u006f\u0069\u006e\u004b\u0065\u0079\u0050\u0061" + - "\u0072\u0074\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u000c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0045\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0040\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u004c\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0049\u0000\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0048\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0054\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u0000\u0000\u0003\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0051\u0000\u0000\u0000\u0042\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004c\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0058\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u006a\u006f\u0069\u006e\u0049\u0064\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0070\u0061\u0072\u0074\u0043\u006f\u0075\u006e" + - "\u0074\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0070\u0061\u0072\u0074\u004e\u0075\u006d\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -public static final org.capnproto.SegmentReader b_9d263a3630b7ebee = - org.capnproto.GeneratedClassSupport.decodeRawBytes( - "\u0000\u0000\u0000\u0000\u0005\u0000\u0006\u0000" + - "\u00ee\u00eb\u00b7\u0030\u0036\u003a\u0026\u009d" + - "\u0037\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u00a1\u00f2\u00da\\\u0088\u00c7\u0084\u00a1" + - "\u0001\u0000\u0007\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0015\u0000\u0000\u0000\u0012\u0002\u0000\u0000" + - "\u0035\u0000\u0000\u0000\u0007\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0031\u0000\u0000\u0000\u00af\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0072\u0075\u006e\u0074\u0069\u006d\u0065\u002f" + - "\u0073\u0072\u0063\u002f\u006d\u0061\u0069\u006e" + - "\u002f\u006a\u0061\u0076\u0061\u002f\u006f\u0072" + - "\u0067\u002f\u0063\u0061\u0070\u006e\u0070\u0072" + - "\u006f\u0074\u006f\u002f\u0072\u0070\u0063\u002d" + - "\u0074\u0077\u006f\u0070\u0061\u0072\u0074\u0079" + - "\u002e\u0063\u0061\u0070\u006e\u0070\u003a\u004a" + - "\u006f\u0069\u006e\u0052\u0065\u0073\u0075\u006c" + - "\u0074\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000" + - "\u000c\u0000\u0000\u0000\u0003\u0000\u0004\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0045\u0000\u0000\u0000\u003a\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0040\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u004c\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0001\u0000\u0000\u0000\u0020\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0049\u0000\u0000\u0000\u0052\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0048\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0054\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u0002\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0001\u0000\u0002\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0051\u0000\u0000\u0000\"\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u004c\u0000\u0000\u0000\u0003\u0000\u0001\u0000" + - "\u0058\u0000\u0000\u0000\u0002\u0000\u0001\u0000" + - "\u006a\u006f\u0069\u006e\u0049\u0064\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0008\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0073\u0075\u0063\u0063\u0065\u0065\u0064\u0065" + - "\u0064\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0063\u0061\u0070\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0012\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + - "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000" + ""); -} -} - diff --git a/runtime/src/test/java/org/capnproto/RpcTest.java b/runtime/src/test/java/org/capnproto/RpcTest.java deleted file mode 100644 index 9345cb9..0000000 --- a/runtime/src/test/java/org/capnproto/RpcTest.java +++ /dev/null @@ -1,410 +0,0 @@ -// Copyright (c) 2018 Sandstorm Development Group, Inc. and contributors -// Licensed under the MIT License: -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -package org.capnproto; - -import org.capnproto.test.Test; - -import org.junit.Assert; - -import java.util.ArrayDeque; -import java.util.HashMap; -import java.util.Map; -import java.util.Queue; -import java.util.concurrent.CompletableFuture; - -class TestNetwork { - - final Map map = new HashMap<>(); - int received = 0; - - TestNetworkAdapter add(String name) { - return this.map.computeIfAbsent( - name, key -> new TestNetworkAdapter(this, name)); - } - - TestNetworkAdapter find(String name) { - return this.map.get(name); - } -} - -class TestNetworkAdapter - implements VatNetwork { - - @Override - public CompletableFuture> baseAccept() { - return this.accept().thenApply(conn -> conn); - } - - class Connection implements VatNetwork.Connection { - - Throwable networkException; - Connection partner; - final Queue messages = new ArrayDeque<>(); - final Queue> fulfillers = new ArrayDeque<>(); - CompletableFuture fulfillOnEnd; - final boolean isClient; - final Test.TestSturdyRef.Reader peerId; - - Connection(boolean isClient, Test.TestSturdyRef.Reader peerId) { - this.isClient = isClient; - this.peerId = peerId; - } - - void attach(Connection other) { - Assert.assertNull(this.partner); - Assert.assertNull(other.partner); - this.partner = other; - other.partner = this; - } - - TestNetwork getNetwork() { - return network; - } - - @Override - public OutgoingRpcMessage newOutgoingMessage(int firstSegmentWordSize) { - var message = new MessageBuilder(firstSegmentWordSize); - - return new OutgoingRpcMessage() { - @Override - public AnyPointer.Builder getBody() { - return message.getRoot(AnyPointer.factory); - } - - @Override - public void send() { - if (networkException != null) { - return; - } - - var incomingMessage = new IncomingRpcMessage() { - @Override - public AnyPointer.Reader getBody() { - return message.getRoot(AnyPointer.factory).asReader(); - } - }; - - if (partner == null) { - return; - } - - if (partner.fulfillers.isEmpty()) { - partner.messages.add(incomingMessage); - } - else { - partner.getNetwork().received++; - var front = partner.fulfillers.remove(); - front.complete(incomingMessage); - } - } - - @Override - public int sizeInWords() { - return 0; - } - }; - } - - @Override - public CompletableFuture receiveIncomingMessage() { - if (this.networkException != null) { - return CompletableFuture.failedFuture(this.networkException); - } - - if (this.messages.isEmpty()) { - if (this.fulfillOnEnd != null) { - this.fulfillOnEnd.complete(null); - return CompletableFuture.completedFuture(null); - } - else { - var promise = new CompletableFuture(); - this.fulfillers.add(promise); - return promise.copy(); - } - } - else { - this.getNetwork().received++; - var result = this.messages.remove(); - return CompletableFuture.completedFuture(result); - } - } - - @Override - public CompletableFuture onDisconnect() { - return null; - } - - @Override - public CompletableFuture shutdown() { - if (this.partner == null) { - return CompletableFuture.completedFuture(null); - } - var promise = new CompletableFuture(); - this.partner.fulfillOnEnd = promise; - return promise.copy(); - } - - public Test.TestSturdyRef.Reader getPeerVatId() { - return this.peerId; - } - } - - final TestNetwork network; - private final String self; - int sent = 0; - int received = 0; - Map connections = new HashMap<>(); - Queue> fulfillerQueue = new ArrayDeque<>(); - Queue connectionQueue = new ArrayDeque<>(); - - TestNetworkAdapter(TestNetwork network, String self) { - this.network = network; - this.self = self; - } - - Connection newConnection(boolean isClient, Test.TestSturdyRef.Reader peerId) { - return new Connection(isClient, peerId); - } - - @Override - public VatNetwork.Connection connect(Test.TestSturdyRef.Reader refId) { - var hostId = refId.getHostId().getHost().toString(); - if (hostId.equals(self)) { - return null; - } - - var dst = this.network.find(hostId); - Assert.assertNotNull(dst); - - var connnection = this.connections.get(dst); - if (connnection != null) { - return connnection; - } - - var local = this.newConnection(true, refId); - var remote = dst.newConnection(false, refId); - local.attach(remote); - - this.connections.put(dst, local); - dst.connections.put(this, remote); - - if (dst.fulfillerQueue.isEmpty()) { - dst.fulfillerQueue.add(CompletableFuture.completedFuture(remote)); - } else { - dst.fulfillerQueue.remove().complete(remote); - } - return local; - } - - public CompletableFuture accept() { - if (this.connections.isEmpty()) { - var promise = new CompletableFuture(); - this.fulfillerQueue.add(promise); - return promise.thenApply(conn -> conn); - } - else { - return CompletableFuture.completedFuture(this.connectionQueue.remove()); - } - } -} - -class TestContext { - final TestNetwork network = new TestNetwork(); - final TestNetworkAdapter clientNetwork; - final TestNetworkAdapter serverNetwork; - - final RpcSystem rpcClient; - final RpcSystem rpcServer; - - TestContext(Capability.Client bootstrapInterface) { - this.clientNetwork = this.network.add("client"); - this.serverNetwork = this.network.add("server"); - this.rpcClient = RpcSystem.makeRpcClient(this.clientNetwork); - this.rpcServer = RpcSystem.makeRpcServer(this.serverNetwork, bootstrapInterface); - } - - TestContext(BootstrapFactory bootstrapFactory) { - this.clientNetwork = this.network.add("client"); - this.serverNetwork = this.network.add("server"); - this.rpcClient = RpcSystem.makeRpcClient(this.clientNetwork); - this.rpcServer = RpcSystem.makeRpcServer(this.serverNetwork, bootstrapFactory); - } - - Capability.Client connect(Test.TestSturdyRefObjectId.Tag tag) { - var message = new MessageBuilder(); - var ref = message.initRoot(Test.TestSturdyRef.factory); - var hostId = ref.initHostId(); - hostId.setHost("server"); - ref.getObjectId().initAs(Test.TestSturdyRefObjectId.factory).setTag(tag); - return rpcClient.bootstrap(ref.asReader()); - } -} - -public class RpcTest { - - static BootstrapFactory bootstrapFactory = new BootstrapFactory<>() { - @Override - public FromPointerReader getVatIdFactory() { - return Test.TestSturdyRef.factory; - } - - @Override - public Capability.Client createFor(Test.TestSturdyRef.Reader refId) { - var callCount = new Counter(); - var handleCount = new Counter(); - - var objectId = refId.getObjectId().getAs(Test.TestSturdyRefObjectId.factory); - var tag = objectId.getTag(); - switch (tag) { - case TEST_INTERFACE: - return new Capability.Client(new TestUtil.TestInterfaceImpl(callCount)); - case TEST_EXTENDS: - return new Capability.Client(Capability.newBrokenCap("No TestExtends implemented.")); - case TEST_PIPELINE: - return new Capability.Client(new TestUtil.TestPipelineImpl(callCount)); - case TEST_TAIL_CALLEE: - return new Capability.Client(new TestUtil.TestTailCalleeImpl(callCount)); - case TEST_TAIL_CALLER: - return new Capability.Client(new TestUtil.TestTailCallerImpl(callCount)); - case TEST_MORE_STUFF: - return new Capability.Client(new TestUtil.TestMoreStuffImpl(callCount, handleCount)); - default: - return new Capability.Client(); - } - } - }; - - @org.junit.Test - public void testBasic() { - var context = new TestContext(bootstrapFactory); - var client = new Test.TestInterface.Client(context.connect(Test.TestSturdyRefObjectId.Tag.TEST_INTERFACE)); - var request1 = client.fooRequest(); - request1.getParams().setI(123); - request1.getParams().setJ(true); - var promise1 = request1.send(); - - final var ref = new Object() { - boolean barFailed = false; - }; - var request3 = client.barRequest(); - var promise3 = request3.send().exceptionally(exc -> { - ref.barFailed = true; - return null; - }); - - var request2 = client.bazRequest(); - TestUtil.initTestMessage(request2.getParams().initS()); - var promise2 = request2.send(); - - var response1 = promise1.join(); - Assert.assertEquals("foo", response1.getX().toString()); - - var response2 = promise2.join(); - promise3.join(); - - Assert.assertTrue(ref.barFailed); - } - - @org.junit.Test - public void testPipelining() { - var context = new TestContext(bootstrapFactory); - var client = new Test.TestPipeline.Client(context.connect(Test.TestSturdyRefObjectId.Tag.TEST_PIPELINE)); - - var chainedCallCount = new Counter(); - - var request = client.getCapRequest(); - request.getParams().setN(234); - request.getParams().setInCap(new TestUtil.TestInterfaceImpl(chainedCallCount)); - - var promise = request.send(); - - var pipelineRequest = promise.getOutBox().getCap().fooRequest(); - pipelineRequest.getParams().setI(321); - - var pipelinePromise = pipelineRequest.send(); - - var pipelineRequest2 = new Test.TestExtends.Client(promise.getOutBox().getCap()).graultRequest(); - var pipelinePromise2 = pipelineRequest2.send(); - - promise = null; - - //Assert.assertEquals(0, chainedCallCount.value()); - - var response = pipelinePromise.join(); - Assert.assertEquals("bar", response.getX().toString()); - - var response2 = pipelinePromise2.join(); - TestUtil.checkTestMessage(response2); - - Assert.assertEquals(1, chainedCallCount.value()); - } - - @org.junit.Test - public void testRelease() { - var context = new TestContext(bootstrapFactory); - var client = new Test.TestMoreStuff.Client(context.connect(Test.TestSturdyRefObjectId.Tag.TEST_MORE_STUFF)); - - var handle1 = client.getHandleRequest().send().join().getHandle(); - var promise = client.getHandleRequest().send(); - var handle2 = promise.join().getHandle(); - - handle1 = null; - handle2 = null; - } - - @org.junit.Test - public void testPromiseResolve() { - var context = new TestContext(bootstrapFactory); - var client = new Test.TestMoreStuff.Client(context.connect(Test.TestSturdyRefObjectId.Tag.TEST_MORE_STUFF)); - - var chainedCallCount = new Counter(); - - var request = client.callFooRequest(); - var request2 = client.callFooWhenResolvedRequest(); - - var paf = new CompletableFuture(); - - { - request.getParams().setCap(new Test.TestInterface.Client(paf.copy())); - request2.getParams().setCap(new Test.TestInterface.Client(paf.copy())); - } - - var promise = request.send(); - var promise2 = request2.send(); - - // Make sure getCap() has been called on the server side by sending another call and waiting - // for it. - Assert.assertEquals(2, client.getCallSequenceRequest().send().join().getN()); - //Assert.assertEquals(3, context.restorer.callCount); - - // OK, now fulfill the local promise. - paf.complete(new Test.TestInterface.Client(new TestUtil.TestInterfaceImpl(chainedCallCount))); - - // We should now be able to wait for getCap() to finish. - Assert.assertEquals("bar", promise.join().getS().toString()); - Assert.assertEquals("bar", promise2.join().getS().toString()); - - //Assert.assertEquals(3, context.restorer.callCount); - Assert.assertEquals(2, chainedCallCount.value()); - } -} - diff --git a/runtime/src/test/java/org/capnproto/demo/demo.capnp b/runtime/src/test/java/org/capnproto/demo/demo.capnp deleted file mode 100644 index efdbc9e..0000000 --- a/runtime/src/test/java/org/capnproto/demo/demo.capnp +++ /dev/null @@ -1,59 +0,0 @@ -@0xb6577a1582e84742; - -using Java = import "/capnp/java.capnp"; -$Java.package("org.capnproto.demo"); -$Java.outerClassname("Demo"); - -struct TestParams0 { - param0 @0 :Int32; -} - -struct TestResults0 { - result0 @0 :Int32; -} - -struct TestParams1 { - param0 @0 :AnyPointer; -} - -struct TestResults1 { - result0 @0 :AnyPointer; - result1 @1 :AnyPointer; - result2 @2 :AnyPointer; -} - -struct Struct0 { - f0 @0 :Bool; -} - -interface Iface0 { - method0 @0 (); - method1 @1 () -> stream; -} - -struct Struct2 { - f0 @0 :AnyPointer; - f1i @1 :Iface0; -} - -interface TestCap0 { - testMethod0 @0 TestParams0 -> TestResults0; - testMethod1 @1 TestParams1 -> TestResults1; -} - -interface TestCap1 { -} - - -interface Iface1 { - - struct Struct1 { - f0 @0 :Bool; - f1 @1 :AnyPointer; - } - - method0 @0 () -> (result0 :Struct0, result1 :Struct1); - method1 @1 () -> (result0: Iface0); -} - - diff --git a/runtime/src/test/java/org/capnproto/demo/demo.capnp.c++ b/runtime/src/test/java/org/capnproto/demo/demo.capnp.c++ deleted file mode 100644 index 121e736..0000000 --- a/runtime/src/test/java/org/capnproto/demo/demo.capnp.c++ +++ /dev/null @@ -1,1236 +0,0 @@ -// Generated by Cap'n Proto compiler, DO NOT EDIT -// source: demo.capnp - -#include "demo.capnp.h" - -namespace capnp { -namespace schemas { -static const ::capnp::_::AlignedData<37> b_91e1b138de965ab0 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 176, 90, 150, 222, 56, 177, 225, 145, - 52, 0, 0, 0, 1, 0, 1, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 0, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 2, 2, 0, 0, - 49, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 63, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 84, 101, 115, 116, - 80, 97, 114, 97, 109, 115, 48, 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, 58, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 3, 0, 1, 0, - 20, 0, 0, 0, 2, 0, 1, 0, - 112, 97, 114, 97, 109, 48, 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, - 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, } -}; -::capnp::word const* const bp_91e1b138de965ab0 = b_91e1b138de965ab0.words; -#if !CAPNP_LITE -static const uint16_t m_91e1b138de965ab0[] = {0}; -static const uint16_t i_91e1b138de965ab0[] = {0}; -const ::capnp::_::RawSchema s_91e1b138de965ab0 = { - 0x91e1b138de965ab0, b_91e1b138de965ab0.words, 37, nullptr, m_91e1b138de965ab0, - 0, 1, i_91e1b138de965ab0, nullptr, nullptr, { &s_91e1b138de965ab0, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<38> b_a77bdd3c3bd1dcbf = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 191, 220, 209, 59, 60, 221, 123, 167, - 52, 0, 0, 0, 1, 0, 1, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 0, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 10, 2, 0, 0, - 53, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 49, 0, 0, 0, 63, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 84, 101, 115, 116, - 82, 101, 115, 117, 108, 116, 115, 48, - 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, - 0, 0, 1, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 13, 0, 0, 0, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 3, 0, 1, 0, - 20, 0, 0, 0, 2, 0, 1, 0, - 114, 101, 115, 117, 108, 116, 48, 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, - 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, } -}; -::capnp::word const* const bp_a77bdd3c3bd1dcbf = b_a77bdd3c3bd1dcbf.words; -#if !CAPNP_LITE -static const uint16_t m_a77bdd3c3bd1dcbf[] = {0}; -static const uint16_t i_a77bdd3c3bd1dcbf[] = {0}; -const ::capnp::_::RawSchema s_a77bdd3c3bd1dcbf = { - 0xa77bdd3c3bd1dcbf, b_a77bdd3c3bd1dcbf.words, 38, nullptr, m_a77bdd3c3bd1dcbf, - 0, 1, i_a77bdd3c3bd1dcbf, nullptr, nullptr, { &s_a77bdd3c3bd1dcbf, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<37> b_b20f33e412339049 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 73, 144, 51, 18, 228, 51, 15, 178, - 52, 0, 0, 0, 1, 0, 0, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 1, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 2, 2, 0, 0, - 49, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 63, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 84, 101, 115, 116, - 80, 97, 114, 97, 109, 115, 49, 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, 58, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 3, 0, 1, 0, - 20, 0, 0, 0, 2, 0, 1, 0, - 112, 97, 114, 97, 109, 48, 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, - 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, } -}; -::capnp::word const* const bp_b20f33e412339049 = b_b20f33e412339049.words; -#if !CAPNP_LITE -static const uint16_t m_b20f33e412339049[] = {0}; -static const uint16_t i_b20f33e412339049[] = {0}; -const ::capnp::_::RawSchema s_b20f33e412339049 = { - 0xb20f33e412339049, b_b20f33e412339049.words, 37, nullptr, m_b20f33e412339049, - 0, 1, i_b20f33e412339049, nullptr, nullptr, { &s_b20f33e412339049, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<68> b_d1342392ab536963 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 99, 105, 83, 171, 146, 35, 52, 209, - 52, 0, 0, 0, 1, 0, 0, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 3, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 10, 2, 0, 0, - 53, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 49, 0, 0, 0, 175, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 84, 101, 115, 116, - 82, 101, 115, 117, 108, 116, 115, 49, - 0, 0, 0, 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, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 64, 0, 0, 0, 3, 0, 1, 0, - 76, 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, - 73, 0, 0, 0, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 68, 0, 0, 0, 3, 0, 1, 0, - 80, 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, - 77, 0, 0, 0, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 72, 0, 0, 0, 3, 0, 1, 0, - 84, 0, 0, 0, 2, 0, 1, 0, - 114, 101, 115, 117, 108, 116, 48, 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, - 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, - 114, 101, 115, 117, 108, 116, 49, 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, - 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, - 114, 101, 115, 117, 108, 116, 50, 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, - 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, } -}; -::capnp::word const* const bp_d1342392ab536963 = b_d1342392ab536963.words; -#if !CAPNP_LITE -static const uint16_t m_d1342392ab536963[] = {0, 1, 2}; -static const uint16_t i_d1342392ab536963[] = {0, 1, 2}; -const ::capnp::_::RawSchema s_d1342392ab536963 = { - 0xd1342392ab536963, b_d1342392ab536963.words, 68, nullptr, m_d1342392ab536963, - 0, 3, i_d1342392ab536963, nullptr, nullptr, { &s_d1342392ab536963, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<37> b_b1af51b6aef0e7bc = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 188, 231, 240, 174, 182, 81, 175, 177, - 52, 0, 0, 0, 1, 0, 1, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 0, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 226, 1, 0, 0, - 49, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 63, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 83, 116, 114, 117, - 99, 116, 48, 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, 26, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 3, 0, 1, 0, - 20, 0, 0, 0, 2, 0, 1, 0, - 102, 48, 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, - 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, } -}; -::capnp::word const* const bp_b1af51b6aef0e7bc = b_b1af51b6aef0e7bc.words; -#if !CAPNP_LITE -static const uint16_t m_b1af51b6aef0e7bc[] = {0}; -static const uint16_t i_b1af51b6aef0e7bc[] = {0}; -const ::capnp::_::RawSchema s_b1af51b6aef0e7bc = { - 0xb1af51b6aef0e7bc, b_b1af51b6aef0e7bc.words, 37, nullptr, m_b1af51b6aef0e7bc, - 0, 1, i_b1af51b6aef0e7bc, nullptr, nullptr, { &s_b1af51b6aef0e7bc, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<43> b_ac6d126c2fac16eb = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 235, 22, 172, 47, 108, 18, 109, 172, - 52, 0, 0, 0, 3, 0, 0, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 218, 1, 0, 0, - 49, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 135, 0, 0, 0, - 125, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 48, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1, 0, 1, 0, - 8, 0, 0, 0, 3, 0, 5, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 75, 41, 118, 170, 237, 119, 141, 188, - 62, 103, 132, 166, 74, 226, 68, 247, - 49, 0, 0, 0, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 37, 0, 0, 0, 7, 0, 0, 0, - 1, 0, 0, 0, 0, 0, 0, 0, - 36, 243, 52, 210, 120, 91, 194, 200, - 110, 177, 192, 119, 51, 154, 95, 153, - 25, 0, 0, 0, 66, 0, 0, 0, - 0, 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, 7, 0, 0, 0, - 109, 101, 116, 104, 111, 100, 48, 0, - 0, 0, 0, 0, 0, 0, 1, 0, - 109, 101, 116, 104, 111, 100, 49, 0, - 0, 0, 0, 0, 0, 0, 1, 0, - 0, 0, 0, 0, 1, 0, 1, 0, } -}; -::capnp::word const* const bp_ac6d126c2fac16eb = b_ac6d126c2fac16eb.words; -#if !CAPNP_LITE -static const ::capnp::_::RawSchema* const d_ac6d126c2fac16eb[] = { - &s_995f9a3377c0b16e, - &s_bc8d77edaa76294b, - &s_c8c25b78d234f324, - &s_f744e24aa684673e, -}; -static const uint16_t m_ac6d126c2fac16eb[] = {0, 1}; -const ::capnp::_::RawSchema s_ac6d126c2fac16eb = { - 0xac6d126c2fac16eb, b_ac6d126c2fac16eb.words, 43, d_ac6d126c2fac16eb, m_ac6d126c2fac16eb, - 4, 2, nullptr, nullptr, nullptr, { &s_ac6d126c2fac16eb, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<22> b_bc8d77edaa76294b = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 75, 41, 118, 170, 237, 119, 141, 188, - 59, 0, 0, 0, 1, 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, - 21, 0, 0, 0, 82, 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 48, 46, 109, 101, 116, 104, 111, - 100, 48, 36, 80, 97, 114, 97, 109, - 115, 0, 0, 0, 0, 0, 0, 0, } -}; -::capnp::word const* const bp_bc8d77edaa76294b = b_bc8d77edaa76294b.words; -#if !CAPNP_LITE -const ::capnp::_::RawSchema s_bc8d77edaa76294b = { - 0xbc8d77edaa76294b, b_bc8d77edaa76294b.words, 22, nullptr, nullptr, - 0, 0, nullptr, nullptr, nullptr, { &s_bc8d77edaa76294b, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<22> b_f744e24aa684673e = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 62, 103, 132, 166, 74, 226, 68, 247, - 59, 0, 0, 0, 1, 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, - 21, 0, 0, 0, 90, 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 48, 46, 109, 101, 116, 104, 111, - 100, 48, 36, 82, 101, 115, 117, 108, - 116, 115, 0, 0, 0, 0, 0, 0, } -}; -::capnp::word const* const bp_f744e24aa684673e = b_f744e24aa684673e.words; -#if !CAPNP_LITE -const ::capnp::_::RawSchema s_f744e24aa684673e = { - 0xf744e24aa684673e, b_f744e24aa684673e.words, 22, nullptr, nullptr, - 0, 0, nullptr, nullptr, nullptr, { &s_f744e24aa684673e, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<22> b_c8c25b78d234f324 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 36, 243, 52, 210, 120, 91, 194, 200, - 59, 0, 0, 0, 1, 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, - 21, 0, 0, 0, 82, 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 48, 46, 109, 101, 116, 104, 111, - 100, 49, 36, 80, 97, 114, 97, 109, - 115, 0, 0, 0, 0, 0, 0, 0, } -}; -::capnp::word const* const bp_c8c25b78d234f324 = b_c8c25b78d234f324.words; -#if !CAPNP_LITE -const ::capnp::_::RawSchema s_c8c25b78d234f324 = { - 0xc8c25b78d234f324, b_c8c25b78d234f324.words, 22, nullptr, nullptr, - 0, 0, nullptr, nullptr, nullptr, { &s_c8c25b78d234f324, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<52> b_a9395663e97ca3af = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 175, 163, 124, 233, 99, 86, 57, 169, - 52, 0, 0, 0, 1, 0, 0, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 2, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 226, 1, 0, 0, - 49, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 119, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 83, 116, 114, 117, - 99, 116, 50, 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, 26, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 36, 0, 0, 0, 3, 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, 34, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 40, 0, 0, 0, 3, 0, 1, 0, - 52, 0, 0, 0, 2, 0, 1, 0, - 102, 48, 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, - 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, - 102, 49, 105, 0, 0, 0, 0, 0, - 17, 0, 0, 0, 0, 0, 0, 0, - 235, 22, 172, 47, 108, 18, 109, 172, - 0, 0, 0, 0, 0, 0, 0, 0, - 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, } -}; -::capnp::word const* const bp_a9395663e97ca3af = b_a9395663e97ca3af.words; -#if !CAPNP_LITE -static const ::capnp::_::RawSchema* const d_a9395663e97ca3af[] = { - &s_ac6d126c2fac16eb, -}; -static const uint16_t m_a9395663e97ca3af[] = {0, 1}; -static const uint16_t i_a9395663e97ca3af[] = {0, 1}; -const ::capnp::_::RawSchema s_a9395663e97ca3af = { - 0xa9395663e97ca3af, b_a9395663e97ca3af.words, 52, d_a9395663e97ca3af, m_a9395663e97ca3af, - 1, 2, i_a9395663e97ca3af, nullptr, nullptr, { &s_a9395663e97ca3af, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<45> b_9c0c5ee4bb0cc725 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 37, 199, 12, 187, 228, 94, 12, 156, - 52, 0, 0, 0, 3, 0, 0, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 234, 1, 0, 0, - 49, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 135, 0, 0, 0, - 133, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 84, 101, 115, 116, - 67, 97, 112, 48, 0, 0, 0, 0, - 0, 0, 0, 0, 1, 0, 1, 0, - 8, 0, 0, 0, 3, 0, 5, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 176, 90, 150, 222, 56, 177, 225, 145, - 191, 220, 209, 59, 60, 221, 123, 167, - 49, 0, 0, 0, 98, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 41, 0, 0, 0, 7, 0, 0, 0, - 1, 0, 0, 0, 0, 0, 0, 0, - 73, 144, 51, 18, 228, 51, 15, 178, - 99, 105, 83, 171, 146, 35, 52, 209, - 29, 0, 0, 0, 98, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 7, 0, 0, 0, - 116, 101, 115, 116, 77, 101, 116, 104, - 111, 100, 48, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1, 0, - 116, 101, 115, 116, 77, 101, 116, 104, - 111, 100, 49, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1, 0, - 0, 0, 0, 0, 1, 0, 1, 0, } -}; -::capnp::word const* const bp_9c0c5ee4bb0cc725 = b_9c0c5ee4bb0cc725.words; -#if !CAPNP_LITE -static const ::capnp::_::RawSchema* const d_9c0c5ee4bb0cc725[] = { - &s_91e1b138de965ab0, - &s_a77bdd3c3bd1dcbf, - &s_b20f33e412339049, - &s_d1342392ab536963, -}; -static const uint16_t m_9c0c5ee4bb0cc725[] = {0, 1}; -const ::capnp::_::RawSchema s_9c0c5ee4bb0cc725 = { - 0x9c0c5ee4bb0cc725, b_9c0c5ee4bb0cc725.words, 45, d_9c0c5ee4bb0cc725, m_9c0c5ee4bb0cc725, - 4, 2, nullptr, nullptr, nullptr, { &s_9c0c5ee4bb0cc725, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<23> b_d88e8bb64ed6f7b1 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 177, 247, 214, 78, 182, 139, 142, 216, - 52, 0, 0, 0, 3, 0, 0, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 234, 1, 0, 0, - 49, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 45, 0, 0, 0, 7, 0, 0, 0, - 45, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 84, 101, 115, 116, - 67, 97, 112, 49, 0, 0, 0, 0, - 0, 0, 0, 0, 1, 0, 1, 0, - 0, 0, 0, 0, 3, 0, 5, 0, - 0, 0, 0, 0, 1, 0, 1, 0, } -}; -::capnp::word const* const bp_d88e8bb64ed6f7b1 = b_d88e8bb64ed6f7b1.words; -#if !CAPNP_LITE -const ::capnp::_::RawSchema s_d88e8bb64ed6f7b1 = { - 0xd88e8bb64ed6f7b1, b_d88e8bb64ed6f7b1.words, 23, nullptr, nullptr, - 0, 0, nullptr, nullptr, nullptr, { &s_d88e8bb64ed6f7b1, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<46> b_d52dcf38c9f6f7c0 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 192, 247, 246, 201, 56, 207, 45, 213, - 52, 0, 0, 0, 3, 0, 0, 0, - 66, 71, 232, 130, 21, 122, 87, 182, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 218, 1, 0, 0, - 49, 0, 0, 0, 23, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 57, 0, 0, 0, 135, 0, 0, 0, - 137, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 49, 0, 0, 0, 0, 0, 0, - 4, 0, 0, 0, 1, 0, 1, 0, - 56, 221, 253, 251, 98, 168, 12, 128, - 1, 0, 0, 0, 66, 0, 0, 0, - 83, 116, 114, 117, 99, 116, 49, 0, - 8, 0, 0, 0, 3, 0, 5, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 213, 4, 46, 99, 24, 202, 146, 143, - 143, 131, 24, 70, 254, 196, 103, 128, - 49, 0, 0, 0, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 37, 0, 0, 0, 7, 0, 0, 0, - 1, 0, 0, 0, 0, 0, 0, 0, - 214, 90, 174, 3, 7, 146, 137, 240, - 6, 245, 17, 195, 170, 21, 109, 195, - 25, 0, 0, 0, 66, 0, 0, 0, - 0, 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, 7, 0, 0, 0, - 109, 101, 116, 104, 111, 100, 48, 0, - 0, 0, 0, 0, 0, 0, 1, 0, - 109, 101, 116, 104, 111, 100, 49, 0, - 0, 0, 0, 0, 0, 0, 1, 0, - 0, 0, 0, 0, 1, 0, 1, 0, } -}; -::capnp::word const* const bp_d52dcf38c9f6f7c0 = b_d52dcf38c9f6f7c0.words; -#if !CAPNP_LITE -static const ::capnp::_::RawSchema* const d_d52dcf38c9f6f7c0[] = { - &s_8067c4fe4618838f, - &s_8f92ca18632e04d5, - &s_c36d15aac311f506, - &s_f089920703ae5ad6, -}; -static const uint16_t m_d52dcf38c9f6f7c0[] = {0, 1}; -const ::capnp::_::RawSchema s_d52dcf38c9f6f7c0 = { - 0xd52dcf38c9f6f7c0, b_d52dcf38c9f6f7c0.words, 46, d_d52dcf38c9f6f7c0, m_d52dcf38c9f6f7c0, - 4, 2, nullptr, nullptr, nullptr, { &s_d52dcf38c9f6f7c0, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<53> b_800ca862fbfddd38 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 56, 221, 253, 251, 98, 168, 12, 128, - 59, 0, 0, 0, 1, 0, 1, 0, - 192, 247, 246, 201, 56, 207, 45, 213, - 1, 0, 7, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 26, 2, 0, 0, - 53, 0, 0, 0, 7, 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 49, 46, 83, 116, 114, 117, 99, - 116, 49, 0, 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, 26, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 36, 0, 0, 0, 3, 0, 1, 0, - 48, 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, - 45, 0, 0, 0, 26, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 40, 0, 0, 0, 3, 0, 1, 0, - 52, 0, 0, 0, 2, 0, 1, 0, - 102, 48, 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, - 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, - 102, 49, 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, - 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, } -}; -::capnp::word const* const bp_800ca862fbfddd38 = b_800ca862fbfddd38.words; -#if !CAPNP_LITE -static const uint16_t m_800ca862fbfddd38[] = {0, 1}; -static const uint16_t i_800ca862fbfddd38[] = {0, 1}; -const ::capnp::_::RawSchema s_800ca862fbfddd38 = { - 0x800ca862fbfddd38, b_800ca862fbfddd38.words, 53, nullptr, m_800ca862fbfddd38, - 0, 2, i_800ca862fbfddd38, nullptr, nullptr, { &s_800ca862fbfddd38, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<22> b_8f92ca18632e04d5 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 213, 4, 46, 99, 24, 202, 146, 143, - 59, 0, 0, 0, 1, 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, - 21, 0, 0, 0, 82, 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 49, 46, 109, 101, 116, 104, 111, - 100, 48, 36, 80, 97, 114, 97, 109, - 115, 0, 0, 0, 0, 0, 0, 0, } -}; -::capnp::word const* const bp_8f92ca18632e04d5 = b_8f92ca18632e04d5.words; -#if !CAPNP_LITE -const ::capnp::_::RawSchema s_8f92ca18632e04d5 = { - 0x8f92ca18632e04d5, b_8f92ca18632e04d5.words, 22, nullptr, nullptr, - 0, 0, nullptr, nullptr, nullptr, { &s_8f92ca18632e04d5, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<53> b_8067c4fe4618838f = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 143, 131, 24, 70, 254, 196, 103, 128, - 59, 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, - 21, 0, 0, 0, 90, 2, 0, 0, - 0, 0, 0, 0, 0, 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 49, 46, 109, 101, 116, 104, 111, - 100, 48, 36, 82, 101, 115, 117, 108, - 116, 115, 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, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 36, 0, 0, 0, 3, 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, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 40, 0, 0, 0, 3, 0, 1, 0, - 52, 0, 0, 0, 2, 0, 1, 0, - 114, 101, 115, 117, 108, 116, 48, 0, - 16, 0, 0, 0, 0, 0, 0, 0, - 188, 231, 240, 174, 182, 81, 175, 177, - 0, 0, 0, 0, 0, 0, 0, 0, - 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, - 114, 101, 115, 117, 108, 116, 49, 0, - 16, 0, 0, 0, 0, 0, 0, 0, - 56, 221, 253, 251, 98, 168, 12, 128, - 0, 0, 0, 0, 0, 0, 0, 0, - 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, } -}; -::capnp::word const* const bp_8067c4fe4618838f = b_8067c4fe4618838f.words; -#if !CAPNP_LITE -static const ::capnp::_::RawSchema* const d_8067c4fe4618838f[] = { - &s_800ca862fbfddd38, - &s_b1af51b6aef0e7bc, -}; -static const uint16_t m_8067c4fe4618838f[] = {0, 1}; -static const uint16_t i_8067c4fe4618838f[] = {0, 1}; -const ::capnp::_::RawSchema s_8067c4fe4618838f = { - 0x8067c4fe4618838f, b_8067c4fe4618838f.words, 53, d_8067c4fe4618838f, m_8067c4fe4618838f, - 2, 2, i_8067c4fe4618838f, nullptr, nullptr, { &s_8067c4fe4618838f, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<22> b_f089920703ae5ad6 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 214, 90, 174, 3, 7, 146, 137, 240, - 59, 0, 0, 0, 1, 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, - 21, 0, 0, 0, 82, 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, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 49, 46, 109, 101, 116, 104, 111, - 100, 49, 36, 80, 97, 114, 97, 109, - 115, 0, 0, 0, 0, 0, 0, 0, } -}; -::capnp::word const* const bp_f089920703ae5ad6 = b_f089920703ae5ad6.words; -#if !CAPNP_LITE -const ::capnp::_::RawSchema s_f089920703ae5ad6 = { - 0xf089920703ae5ad6, b_f089920703ae5ad6.words, 22, nullptr, nullptr, - 0, 0, nullptr, nullptr, nullptr, { &s_f089920703ae5ad6, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<38> b_c36d15aac311f506 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 6, 245, 17, 195, 170, 21, 109, 195, - 59, 0, 0, 0, 1, 0, 0, 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, - 21, 0, 0, 0, 90, 2, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 49, 0, 0, 0, 63, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 114, 117, 110, 116, 105, 109, 101, 47, - 115, 114, 99, 47, 116, 101, 115, 116, - 47, 106, 97, 118, 97, 47, 111, 114, - 103, 47, 99, 97, 112, 110, 112, 114, - 111, 116, 111, 47, 100, 101, 109, 111, - 47, 100, 101, 109, 111, 46, 99, 97, - 112, 110, 112, 58, 73, 102, 97, 99, - 101, 49, 46, 109, 101, 116, 104, 111, - 100, 49, 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, 66, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 8, 0, 0, 0, 3, 0, 1, 0, - 20, 0, 0, 0, 2, 0, 1, 0, - 114, 101, 115, 117, 108, 116, 48, 0, - 17, 0, 0, 0, 0, 0, 0, 0, - 235, 22, 172, 47, 108, 18, 109, 172, - 0, 0, 0, 0, 0, 0, 0, 0, - 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, } -}; -::capnp::word const* const bp_c36d15aac311f506 = b_c36d15aac311f506.words; -#if !CAPNP_LITE -static const ::capnp::_::RawSchema* const d_c36d15aac311f506[] = { - &s_ac6d126c2fac16eb, -}; -static const uint16_t m_c36d15aac311f506[] = {0}; -static const uint16_t i_c36d15aac311f506[] = {0}; -const ::capnp::_::RawSchema s_c36d15aac311f506 = { - 0xc36d15aac311f506, b_c36d15aac311f506.words, 38, d_c36d15aac311f506, m_c36d15aac311f506, - 1, 1, i_c36d15aac311f506, nullptr, nullptr, { &s_c36d15aac311f506, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -} // namespace schemas -} // namespace capnp - -// ======================================================================================= - - -// TestParams0 -constexpr uint16_t TestParams0::_capnpPrivate::dataWordSize; -constexpr uint16_t TestParams0::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind TestParams0::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* TestParams0::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// TestResults0 -constexpr uint16_t TestResults0::_capnpPrivate::dataWordSize; -constexpr uint16_t TestResults0::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind TestResults0::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* TestResults0::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// TestParams1 -constexpr uint16_t TestParams1::_capnpPrivate::dataWordSize; -constexpr uint16_t TestParams1::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind TestParams1::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* TestParams1::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// TestResults1 -constexpr uint16_t TestResults1::_capnpPrivate::dataWordSize; -constexpr uint16_t TestResults1::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind TestResults1::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* TestResults1::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Struct0 -constexpr uint16_t Struct0::_capnpPrivate::dataWordSize; -constexpr uint16_t Struct0::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Struct0::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Struct0::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -::capnp::Request< ::Iface0::Method0Params, ::Iface0::Method0Results> -Iface0::Client::method0Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) { - return newCall< ::Iface0::Method0Params, ::Iface0::Method0Results>( - 0xac6d126c2fac16ebull, 0, sizeHint); -} -::kj::Promise Iface0::Server::method0(Method0Context) { - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:Iface0", "method0", - 0xac6d126c2fac16ebull, 0); -} -::capnp::StreamingRequest< ::Iface0::Method1Params> -Iface0::Client::method1Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) { - return newStreamingCall< ::Iface0::Method1Params>( - 0xac6d126c2fac16ebull, 1, sizeHint); -} -::kj::Promise Iface0::Server::method1(Method1Context) { - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:Iface0", "method1", - 0xac6d126c2fac16ebull, 1); -} -::capnp::Capability::Server::DispatchCallResult Iface0::Server::dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (interfaceId) { - case 0xac6d126c2fac16ebull: - return dispatchCallInternal(methodId, context); - default: - return internalUnimplemented("runtime/src/test/java/org/capnproto/demo/demo.capnp:Iface0", interfaceId); - } -} -::capnp::Capability::Server::DispatchCallResult Iface0::Server::dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (methodId) { - case 0: - return { - method0(::capnp::Capability::Server::internalGetTypedContext< - ::Iface0::Method0Params, ::Iface0::Method0Results>(context)), - false - }; - case 1: - return { - kj::evalNow([&]() { - return method1(::capnp::Capability::Server::internalGetTypedStreamingContext< - ::Iface0::Method1Params>(context)); - }), - true - }; - default: - (void)context; - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:Iface0", - 0xac6d126c2fac16ebull, methodId); - } -} -#endif // !CAPNP_LITE - -// Iface0 -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface0::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface0::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Iface0::Method0Params -constexpr uint16_t Iface0::Method0Params::_capnpPrivate::dataWordSize; -constexpr uint16_t Iface0::Method0Params::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface0::Method0Params::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface0::Method0Params::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Iface0::Method0Results -constexpr uint16_t Iface0::Method0Results::_capnpPrivate::dataWordSize; -constexpr uint16_t Iface0::Method0Results::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface0::Method0Results::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface0::Method0Results::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Iface0::Method1Params -constexpr uint16_t Iface0::Method1Params::_capnpPrivate::dataWordSize; -constexpr uint16_t Iface0::Method1Params::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface0::Method1Params::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface0::Method1Params::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Struct2 -constexpr uint16_t Struct2::_capnpPrivate::dataWordSize; -constexpr uint16_t Struct2::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Struct2::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Struct2::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -::capnp::Request< ::TestParams0, ::TestResults0> -TestCap0::Client::testMethod0Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) { - return newCall< ::TestParams0, ::TestResults0>( - 0x9c0c5ee4bb0cc725ull, 0, sizeHint); -} -::kj::Promise TestCap0::Server::testMethod0(TestMethod0Context) { - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:TestCap0", "testMethod0", - 0x9c0c5ee4bb0cc725ull, 0); -} -::capnp::Request< ::TestParams1, ::TestResults1> -TestCap0::Client::testMethod1Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) { - return newCall< ::TestParams1, ::TestResults1>( - 0x9c0c5ee4bb0cc725ull, 1, sizeHint); -} -::kj::Promise TestCap0::Server::testMethod1(TestMethod1Context) { - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:TestCap0", "testMethod1", - 0x9c0c5ee4bb0cc725ull, 1); -} -::capnp::Capability::Server::DispatchCallResult TestCap0::Server::dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (interfaceId) { - case 0x9c0c5ee4bb0cc725ull: - return dispatchCallInternal(methodId, context); - default: - return internalUnimplemented("runtime/src/test/java/org/capnproto/demo/demo.capnp:TestCap0", interfaceId); - } -} -::capnp::Capability::Server::DispatchCallResult TestCap0::Server::dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (methodId) { - case 0: - return { - testMethod0(::capnp::Capability::Server::internalGetTypedContext< - ::TestParams0, ::TestResults0>(context)), - false - }; - case 1: - return { - testMethod1(::capnp::Capability::Server::internalGetTypedContext< - ::TestParams1, ::TestResults1>(context)), - false - }; - default: - (void)context; - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:TestCap0", - 0x9c0c5ee4bb0cc725ull, methodId); - } -} -#endif // !CAPNP_LITE - -// TestCap0 -#if !CAPNP_LITE -constexpr ::capnp::Kind TestCap0::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* TestCap0::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -::capnp::Capability::Server::DispatchCallResult TestCap1::Server::dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (interfaceId) { - case 0xd88e8bb64ed6f7b1ull: - return dispatchCallInternal(methodId, context); - default: - return internalUnimplemented("runtime/src/test/java/org/capnproto/demo/demo.capnp:TestCap1", interfaceId); - } -} -::capnp::Capability::Server::DispatchCallResult TestCap1::Server::dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (methodId) { - default: - (void)context; - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:TestCap1", - 0xd88e8bb64ed6f7b1ull, methodId); - } -} -#endif // !CAPNP_LITE - -// TestCap1 -#if !CAPNP_LITE -constexpr ::capnp::Kind TestCap1::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* TestCap1::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -::capnp::Request< ::Iface1::Method0Params, ::Iface1::Method0Results> -Iface1::Client::method0Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) { - return newCall< ::Iface1::Method0Params, ::Iface1::Method0Results>( - 0xd52dcf38c9f6f7c0ull, 0, sizeHint); -} -::kj::Promise Iface1::Server::method0(Method0Context) { - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:Iface1", "method0", - 0xd52dcf38c9f6f7c0ull, 0); -} -::capnp::Request< ::Iface1::Method1Params, ::Iface1::Method1Results> -Iface1::Client::method1Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) { - return newCall< ::Iface1::Method1Params, ::Iface1::Method1Results>( - 0xd52dcf38c9f6f7c0ull, 1, sizeHint); -} -::kj::Promise Iface1::Server::method1(Method1Context) { - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:Iface1", "method1", - 0xd52dcf38c9f6f7c0ull, 1); -} -::capnp::Capability::Server::DispatchCallResult Iface1::Server::dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (interfaceId) { - case 0xd52dcf38c9f6f7c0ull: - return dispatchCallInternal(methodId, context); - default: - return internalUnimplemented("runtime/src/test/java/org/capnproto/demo/demo.capnp:Iface1", interfaceId); - } -} -::capnp::Capability::Server::DispatchCallResult Iface1::Server::dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (methodId) { - case 0: - return { - method0(::capnp::Capability::Server::internalGetTypedContext< - ::Iface1::Method0Params, ::Iface1::Method0Results>(context)), - false - }; - case 1: - return { - method1(::capnp::Capability::Server::internalGetTypedContext< - ::Iface1::Method1Params, ::Iface1::Method1Results>(context)), - false - }; - default: - (void)context; - return ::capnp::Capability::Server::internalUnimplemented( - "runtime/src/test/java/org/capnproto/demo/demo.capnp:Iface1", - 0xd52dcf38c9f6f7c0ull, methodId); - } -} -#endif // !CAPNP_LITE - -// Iface1 -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface1::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface1::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Iface1::Struct1 -constexpr uint16_t Iface1::Struct1::_capnpPrivate::dataWordSize; -constexpr uint16_t Iface1::Struct1::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface1::Struct1::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface1::Struct1::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Iface1::Method0Params -constexpr uint16_t Iface1::Method0Params::_capnpPrivate::dataWordSize; -constexpr uint16_t Iface1::Method0Params::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface1::Method0Params::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface1::Method0Params::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Iface1::Method0Results -constexpr uint16_t Iface1::Method0Results::_capnpPrivate::dataWordSize; -constexpr uint16_t Iface1::Method0Results::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface1::Method0Results::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface1::Method0Results::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Iface1::Method1Params -constexpr uint16_t Iface1::Method1Params::_capnpPrivate::dataWordSize; -constexpr uint16_t Iface1::Method1Params::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface1::Method1Params::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface1::Method1Params::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -// Iface1::Method1Results -constexpr uint16_t Iface1::Method1Results::_capnpPrivate::dataWordSize; -constexpr uint16_t Iface1::Method1Results::_capnpPrivate::pointerCount; -#if !CAPNP_LITE -constexpr ::capnp::Kind Iface1::Method1Results::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* Iface1::Method1Results::_capnpPrivate::schema; -#endif // !CAPNP_LITE - - - diff --git a/runtime/src/test/java/org/capnproto/demo/demo.capnp.h b/runtime/src/test/java/org/capnproto/demo/demo.capnp.h deleted file mode 100644 index bdcd8bc..0000000 --- a/runtime/src/test/java/org/capnproto/demo/demo.capnp.h +++ /dev/null @@ -1,2106 +0,0 @@ -// Generated by Cap'n Proto compiler, DO NOT EDIT -// source: demo.capnp - -#pragma once - -#include -#include -#if !CAPNP_LITE -#include -#endif // !CAPNP_LITE - -#if CAPNP_VERSION != 8000 -#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 capnp { -namespace schemas { - -CAPNP_DECLARE_SCHEMA(91e1b138de965ab0); -CAPNP_DECLARE_SCHEMA(a77bdd3c3bd1dcbf); -CAPNP_DECLARE_SCHEMA(b20f33e412339049); -CAPNP_DECLARE_SCHEMA(d1342392ab536963); -CAPNP_DECLARE_SCHEMA(b1af51b6aef0e7bc); -CAPNP_DECLARE_SCHEMA(ac6d126c2fac16eb); -CAPNP_DECLARE_SCHEMA(bc8d77edaa76294b); -CAPNP_DECLARE_SCHEMA(f744e24aa684673e); -CAPNP_DECLARE_SCHEMA(c8c25b78d234f324); -CAPNP_DECLARE_SCHEMA(a9395663e97ca3af); -CAPNP_DECLARE_SCHEMA(9c0c5ee4bb0cc725); -CAPNP_DECLARE_SCHEMA(d88e8bb64ed6f7b1); -CAPNP_DECLARE_SCHEMA(d52dcf38c9f6f7c0); -CAPNP_DECLARE_SCHEMA(800ca862fbfddd38); -CAPNP_DECLARE_SCHEMA(8f92ca18632e04d5); -CAPNP_DECLARE_SCHEMA(8067c4fe4618838f); -CAPNP_DECLARE_SCHEMA(f089920703ae5ad6); -CAPNP_DECLARE_SCHEMA(c36d15aac311f506); - -} // namespace schemas -} // namespace capnp - - -struct TestParams0 { - TestParams0() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(91e1b138de965ab0, 1, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct TestResults0 { - TestResults0() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(a77bdd3c3bd1dcbf, 1, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct TestParams1 { - TestParams1() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(b20f33e412339049, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct TestResults1 { - TestResults1() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(d1342392ab536963, 0, 3) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Struct0 { - Struct0() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(b1af51b6aef0e7bc, 1, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Iface0 { - Iface0() = delete; - -#if !CAPNP_LITE - class Client; - class Server; -#endif // !CAPNP_LITE - - struct Method0Params; - struct Method0Results; - struct Method1Params; - - #if !CAPNP_LITE - struct _capnpPrivate { - CAPNP_DECLARE_INTERFACE_HEADER(ac6d126c2fac16eb) - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - }; - #endif // !CAPNP_LITE -}; - -struct Iface0::Method0Params { - Method0Params() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(bc8d77edaa76294b, 0, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Iface0::Method0Results { - Method0Results() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(f744e24aa684673e, 0, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Iface0::Method1Params { - Method1Params() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(c8c25b78d234f324, 0, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Struct2 { - Struct2() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(a9395663e97ca3af, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct TestCap0 { - TestCap0() = delete; - -#if !CAPNP_LITE - class Client; - class Server; -#endif // !CAPNP_LITE - - - #if !CAPNP_LITE - struct _capnpPrivate { - CAPNP_DECLARE_INTERFACE_HEADER(9c0c5ee4bb0cc725) - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - }; - #endif // !CAPNP_LITE -}; - -struct TestCap1 { - TestCap1() = delete; - -#if !CAPNP_LITE - class Client; - class Server; -#endif // !CAPNP_LITE - - - #if !CAPNP_LITE - struct _capnpPrivate { - CAPNP_DECLARE_INTERFACE_HEADER(d88e8bb64ed6f7b1) - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - }; - #endif // !CAPNP_LITE -}; - -struct Iface1 { - Iface1() = delete; - -#if !CAPNP_LITE - class Client; - class Server; -#endif // !CAPNP_LITE - - struct Struct1; - struct Method0Params; - struct Method0Results; - struct Method1Params; - struct Method1Results; - - #if !CAPNP_LITE - struct _capnpPrivate { - CAPNP_DECLARE_INTERFACE_HEADER(d52dcf38c9f6f7c0) - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - }; - #endif // !CAPNP_LITE -}; - -struct Iface1::Struct1 { - Struct1() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(800ca862fbfddd38, 1, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Iface1::Method0Params { - Method0Params() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(8f92ca18632e04d5, 0, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Iface1::Method0Results { - Method0Results() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(8067c4fe4618838f, 0, 2) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Iface1::Method1Params { - Method1Params() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(f089920703ae5ad6, 0, 0) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -struct Iface1::Method1Results { - Method1Results() = delete; - - class Reader; - class Builder; - class Pipeline; - - struct _capnpPrivate { - CAPNP_DECLARE_STRUCT_HEADER(c36d15aac311f506, 0, 1) - #if !CAPNP_LITE - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - #endif // !CAPNP_LITE - }; -}; - -// ======================================================================================= - -class TestParams0::Reader { -public: - typedef TestParams0 Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline ::int32_t getParam0() 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; -}; - -class TestParams0::Builder { -public: - typedef TestParams0 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline ::int32_t getParam0(); - inline void setParam0( ::int32_t value); - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class TestParams0::Pipeline { -public: - typedef TestParams0 Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class TestResults0::Reader { -public: - typedef TestResults0 Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline ::int32_t getResult0() 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; -}; - -class TestResults0::Builder { -public: - typedef TestResults0 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline ::int32_t getResult0(); - inline void setResult0( ::int32_t value); - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class TestResults0::Pipeline { -public: - typedef TestResults0 Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class TestParams1::Reader { -public: - typedef TestParams1 Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline bool hasParam0() const; - inline ::capnp::AnyPointer::Reader getParam0() 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; -}; - -class TestParams1::Builder { -public: - typedef TestParams1 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline bool hasParam0(); - inline ::capnp::AnyPointer::Builder getParam0(); - inline ::capnp::AnyPointer::Builder initParam0(); - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class TestParams1::Pipeline { -public: - typedef TestParams1 Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class TestResults1::Reader { -public: - typedef TestResults1 Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline bool hasResult0() const; - inline ::capnp::AnyPointer::Reader getResult0() const; - - inline bool hasResult1() const; - inline ::capnp::AnyPointer::Reader getResult1() const; - - inline bool hasResult2() const; - inline ::capnp::AnyPointer::Reader getResult2() 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; -}; - -class TestResults1::Builder { -public: - typedef TestResults1 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline bool hasResult0(); - inline ::capnp::AnyPointer::Builder getResult0(); - inline ::capnp::AnyPointer::Builder initResult0(); - - inline bool hasResult1(); - inline ::capnp::AnyPointer::Builder getResult1(); - inline ::capnp::AnyPointer::Builder initResult1(); - - inline bool hasResult2(); - inline ::capnp::AnyPointer::Builder getResult2(); - inline ::capnp::AnyPointer::Builder initResult2(); - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class TestResults1::Pipeline { -public: - typedef TestResults1 Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class Struct0::Reader { -public: - typedef Struct0 Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline bool getF0() 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; -}; - -class 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline bool getF0(); - inline void setF0(bool value); - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Struct0::Pipeline { -public: - typedef Struct0 Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -class Iface0::Client - : public virtual ::capnp::Capability::Client { -public: - typedef Iface0 Calls; - typedef Iface0 Reads; - - Client(decltype(nullptr)); - explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); - template ()>> - Client(::kj::Own<_t>&& server); - template ()>> - Client(::kj::Promise<_t>&& promise); - Client(::kj::Exception&& exception); - Client(Client&) = default; - Client(Client&&) = default; - Client& operator=(Client& other); - Client& operator=(Client&& other); - - ::capnp::Request< ::Iface0::Method0Params, ::Iface0::Method0Results> method0Request( - ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); - ::capnp::StreamingRequest< ::Iface0::Method1Params> method1Request( - ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); - -protected: - Client() = default; -}; - -class Iface0::Server - : public virtual ::capnp::Capability::Server { -public: - typedef Iface0 Serves; - - ::capnp::Capability::Server::DispatchCallResult dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) - override; - -protected: - typedef ::Iface0::Method0Params Method0Params; - typedef ::Iface0::Method0Results Method0Results; - typedef ::capnp::CallContext Method0Context; - virtual ::kj::Promise method0(Method0Context context); - typedef ::Iface0::Method1Params Method1Params; - typedef ::capnp::StreamingCallContext Method1Context; - virtual ::kj::Promise method1(Method1Context context); - - inline ::Iface0::Client thisCap() { - return ::capnp::Capability::Server::thisCap() - .template castAs< ::Iface0>(); - } - - ::capnp::Capability::Server::DispatchCallResult dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); -}; -#endif // !CAPNP_LITE - -class Iface0::Method0Params::Reader { -public: - typedef Method0Params Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - -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; -}; - -class Iface0::Method0Params::Builder { -public: - typedef Method0Params 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Iface0::Method0Params::Pipeline { -public: - typedef Method0Params Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class Iface0::Method0Results::Reader { -public: - typedef Method0Results Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - -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; -}; - -class Iface0::Method0Results::Builder { -public: - typedef Method0Results 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Iface0::Method0Results::Pipeline { -public: - typedef Method0Results Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class Iface0::Method1Params::Reader { -public: - typedef Method1Params Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - -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; -}; - -class Iface0::Method1Params::Builder { -public: - typedef Method1Params 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Iface0::Method1Params::Pipeline { -public: - typedef Method1Params Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class Struct2::Reader { -public: - typedef Struct2 Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline bool hasF0() const; - inline ::capnp::AnyPointer::Reader getF0() const; - - inline bool hasF1i() const; -#if !CAPNP_LITE - inline ::Iface0::Client getF1i() const; -#endif // !CAPNP_LITE - -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; -}; - -class Struct2::Builder { -public: - typedef Struct2 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline bool hasF0(); - inline ::capnp::AnyPointer::Builder getF0(); - inline ::capnp::AnyPointer::Builder initF0(); - - inline bool hasF1i(); -#if !CAPNP_LITE - inline ::Iface0::Client getF1i(); - inline void setF1i( ::Iface0::Client&& value); - inline void setF1i( ::Iface0::Client& value); - inline void adoptF1i(::capnp::Orphan< ::Iface0>&& value); - inline ::capnp::Orphan< ::Iface0> disownF1i(); -#endif // !CAPNP_LITE - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Struct2::Pipeline { -public: - typedef Struct2 Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - - inline ::Iface0::Client getF1i(); -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -class TestCap0::Client - : public virtual ::capnp::Capability::Client { -public: - typedef TestCap0 Calls; - typedef TestCap0 Reads; - - Client(decltype(nullptr)); - explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); - template ()>> - Client(::kj::Own<_t>&& server); - template ()>> - Client(::kj::Promise<_t>&& promise); - Client(::kj::Exception&& exception); - Client(Client&) = default; - Client(Client&&) = default; - Client& operator=(Client& other); - Client& operator=(Client&& other); - - ::capnp::Request< ::TestParams0, ::TestResults0> testMethod0Request( - ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); - ::capnp::Request< ::TestParams1, ::TestResults1> testMethod1Request( - ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); - -protected: - Client() = default; -}; - -class TestCap0::Server - : public virtual ::capnp::Capability::Server { -public: - typedef TestCap0 Serves; - - ::capnp::Capability::Server::DispatchCallResult dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) - override; - -protected: - typedef ::capnp::CallContext< ::TestParams0, ::TestResults0> TestMethod0Context; - virtual ::kj::Promise testMethod0(TestMethod0Context context); - typedef ::capnp::CallContext< ::TestParams1, ::TestResults1> TestMethod1Context; - virtual ::kj::Promise testMethod1(TestMethod1Context context); - - inline ::TestCap0::Client thisCap() { - return ::capnp::Capability::Server::thisCap() - .template castAs< ::TestCap0>(); - } - - ::capnp::Capability::Server::DispatchCallResult dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); -}; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -class TestCap1::Client - : public virtual ::capnp::Capability::Client { -public: - typedef TestCap1 Calls; - typedef TestCap1 Reads; - - Client(decltype(nullptr)); - explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); - template ()>> - Client(::kj::Own<_t>&& server); - template ()>> - Client(::kj::Promise<_t>&& promise); - Client(::kj::Exception&& exception); - Client(Client&) = default; - Client(Client&&) = default; - Client& operator=(Client& other); - Client& operator=(Client&& other); - - -protected: - Client() = default; -}; - -class TestCap1::Server - : public virtual ::capnp::Capability::Server { -public: - typedef TestCap1 Serves; - - ::capnp::Capability::Server::DispatchCallResult dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) - override; - -protected: - - inline ::TestCap1::Client thisCap() { - return ::capnp::Capability::Server::thisCap() - .template castAs< ::TestCap1>(); - } - - ::capnp::Capability::Server::DispatchCallResult dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); -}; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -class Iface1::Client - : public virtual ::capnp::Capability::Client { -public: - typedef Iface1 Calls; - typedef Iface1 Reads; - - Client(decltype(nullptr)); - explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); - template ()>> - Client(::kj::Own<_t>&& server); - template ()>> - Client(::kj::Promise<_t>&& promise); - Client(::kj::Exception&& exception); - Client(Client&) = default; - Client(Client&&) = default; - Client& operator=(Client& other); - Client& operator=(Client&& other); - - ::capnp::Request< ::Iface1::Method0Params, ::Iface1::Method0Results> method0Request( - ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); - ::capnp::Request< ::Iface1::Method1Params, ::Iface1::Method1Results> method1Request( - ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); - -protected: - Client() = default; -}; - -class Iface1::Server - : public virtual ::capnp::Capability::Server { -public: - typedef Iface1 Serves; - - ::capnp::Capability::Server::DispatchCallResult dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) - override; - -protected: - typedef ::Iface1::Method0Params Method0Params; - typedef ::Iface1::Method0Results Method0Results; - typedef ::capnp::CallContext Method0Context; - virtual ::kj::Promise method0(Method0Context context); - typedef ::Iface1::Method1Params Method1Params; - typedef ::Iface1::Method1Results Method1Results; - typedef ::capnp::CallContext Method1Context; - virtual ::kj::Promise method1(Method1Context context); - - inline ::Iface1::Client thisCap() { - return ::capnp::Capability::Server::thisCap() - .template castAs< ::Iface1>(); - } - - ::capnp::Capability::Server::DispatchCallResult dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); -}; -#endif // !CAPNP_LITE - -class Iface1::Struct1::Reader { -public: - typedef Struct1 Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline bool getF0() const; - - inline bool hasF1() const; - inline ::capnp::AnyPointer::Reader getF1() 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; -}; - -class Iface1::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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline bool getF0(); - inline void setF0(bool value); - - inline bool hasF1(); - inline ::capnp::AnyPointer::Builder getF1(); - inline ::capnp::AnyPointer::Builder initF1(); - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Iface1::Struct1::Pipeline { -public: - typedef Struct1 Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class Iface1::Method0Params::Reader { -public: - typedef Method0Params Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - -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; -}; - -class Iface1::Method0Params::Builder { -public: - typedef Method0Params 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Iface1::Method0Params::Pipeline { -public: - typedef Method0Params Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class Iface1::Method0Results::Reader { -public: - typedef Method0Results Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline bool hasResult0() const; - inline ::Struct0::Reader getResult0() const; - - inline bool hasResult1() const; - inline ::Iface1::Struct1::Reader getResult1() 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; -}; - -class Iface1::Method0Results::Builder { -public: - typedef Method0Results 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline bool hasResult0(); - inline ::Struct0::Builder getResult0(); - inline void setResult0( ::Struct0::Reader value); - inline ::Struct0::Builder initResult0(); - inline void adoptResult0(::capnp::Orphan< ::Struct0>&& value); - inline ::capnp::Orphan< ::Struct0> disownResult0(); - - inline bool hasResult1(); - inline ::Iface1::Struct1::Builder getResult1(); - inline void setResult1( ::Iface1::Struct1::Reader value); - inline ::Iface1::Struct1::Builder initResult1(); - inline void adoptResult1(::capnp::Orphan< ::Iface1::Struct1>&& value); - inline ::capnp::Orphan< ::Iface1::Struct1> disownResult1(); - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Iface1::Method0Results::Pipeline { -public: - typedef Method0Results Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - - inline ::Struct0::Pipeline getResult0(); - inline ::Iface1::Struct1::Pipeline getResult1(); -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class Iface1::Method1Params::Reader { -public: - typedef Method1Params Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - -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; -}; - -class Iface1::Method1Params::Builder { -public: - typedef Method1Params 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Iface1::Method1Params::Pipeline { -public: - typedef Method1Params Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -class Iface1::Method1Results::Reader { -public: - typedef Method1Results Reads; - - Reader() = default; - inline explicit Reader(::capnp::_::StructReader base): _reader(base) {} - - inline ::capnp::MessageSize totalSize() const { - return _reader.totalSize().asPublic(); - } - -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { - return ::capnp::_::structString(_reader, *_capnpPrivate::brand()); - } -#endif // !CAPNP_LITE - - inline bool hasResult0() const; -#if !CAPNP_LITE - inline ::Iface0::Client getResult0() const; -#endif // !CAPNP_LITE - -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; -}; - -class Iface1::Method1Results::Builder { -public: - typedef Method1Results 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 ::capnp::MessageSize totalSize() const { return asReader().totalSize(); } -#if !CAPNP_LITE - inline ::kj::StringTree toString() const { return asReader().toString(); } -#endif // !CAPNP_LITE - - inline bool hasResult0(); -#if !CAPNP_LITE - inline ::Iface0::Client getResult0(); - inline void setResult0( ::Iface0::Client&& value); - inline void setResult0( ::Iface0::Client& value); - inline void adoptResult0(::capnp::Orphan< ::Iface0>&& value); - inline ::capnp::Orphan< ::Iface0> disownResult0(); -#endif // !CAPNP_LITE - -private: - ::capnp::_::StructBuilder _builder; - template - friend struct ::capnp::ToDynamic_; - friend class ::capnp::Orphanage; - template - friend struct ::capnp::_::PointerHelpers; -}; - -#if !CAPNP_LITE -class Iface1::Method1Results::Pipeline { -public: - typedef Method1Results Pipelines; - - inline Pipeline(decltype(nullptr)): _typeless(nullptr) {} - inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless) - : _typeless(kj::mv(typeless)) {} - - inline ::Iface0::Client getResult0(); -private: - ::capnp::AnyPointer::Pipeline _typeless; - friend class ::capnp::PipelineHook; - template - friend struct ::capnp::ToDynamic_; -}; -#endif // !CAPNP_LITE - -// ======================================================================================= - -inline ::int32_t TestParams0::Reader::getParam0() const { - return _reader.getDataField< ::int32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} - -inline ::int32_t TestParams0::Builder::getParam0() { - return _builder.getDataField< ::int32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} -inline void TestParams0::Builder::setParam0( ::int32_t value) { - _builder.setDataField< ::int32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); -} - -inline ::int32_t TestResults0::Reader::getResult0() const { - return _reader.getDataField< ::int32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} - -inline ::int32_t TestResults0::Builder::getResult0() { - return _builder.getDataField< ::int32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} -inline void TestResults0::Builder::setResult0( ::int32_t value) { - _builder.setDataField< ::int32_t>( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); -} - -inline bool TestParams1::Reader::hasParam0() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline bool TestParams1::Builder::hasParam0() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::AnyPointer::Reader TestParams1::Reader::getParam0() const { - return ::capnp::AnyPointer::Reader(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder TestParams1::Builder::getParam0() { - return ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder TestParams1::Builder::initParam0() { - auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); - result.clear(); - return result; -} - -inline bool TestResults1::Reader::hasResult0() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline bool TestResults1::Builder::hasResult0() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::AnyPointer::Reader TestResults1::Reader::getResult0() const { - return ::capnp::AnyPointer::Reader(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder TestResults1::Builder::getResult0() { - return ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder TestResults1::Builder::initResult0() { - auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); - result.clear(); - return result; -} - -inline bool TestResults1::Reader::hasResult1() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline bool TestResults1::Builder::hasResult1() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::AnyPointer::Reader TestResults1::Reader::getResult1() const { - return ::capnp::AnyPointer::Reader(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder TestResults1::Builder::getResult1() { - return ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder TestResults1::Builder::initResult1() { - auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); - result.clear(); - return result; -} - -inline bool TestResults1::Reader::hasResult2() const { - return !_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline bool TestResults1::Builder::hasResult2() { - return !_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::AnyPointer::Reader TestResults1::Reader::getResult2() const { - return ::capnp::AnyPointer::Reader(_reader.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder TestResults1::Builder::getResult2() { - return ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder TestResults1::Builder::initResult2() { - auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<2>() * ::capnp::POINTERS)); - result.clear(); - return result; -} - -inline bool Struct0::Reader::getF0() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} - -inline bool Struct0::Builder::getF0() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} -inline void Struct0::Builder::setF0(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); -} - -#if !CAPNP_LITE -inline Iface0::Client::Client(decltype(nullptr)) - : ::capnp::Capability::Client(nullptr) {} -inline Iface0::Client::Client( - ::kj::Own< ::capnp::ClientHook>&& hook) - : ::capnp::Capability::Client(::kj::mv(hook)) {} -template -inline Iface0::Client::Client(::kj::Own<_t>&& server) - : ::capnp::Capability::Client(::kj::mv(server)) {} -template -inline Iface0::Client::Client(::kj::Promise<_t>&& promise) - : ::capnp::Capability::Client(::kj::mv(promise)) {} -inline Iface0::Client::Client(::kj::Exception&& exception) - : ::capnp::Capability::Client(::kj::mv(exception)) {} -inline ::Iface0::Client& Iface0::Client::operator=(Client& other) { - ::capnp::Capability::Client::operator=(other); - return *this; -} -inline ::Iface0::Client& Iface0::Client::operator=(Client&& other) { - ::capnp::Capability::Client::operator=(kj::mv(other)); - return *this; -} - -#endif // !CAPNP_LITE -inline bool Struct2::Reader::hasF0() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline bool Struct2::Builder::hasF0() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::AnyPointer::Reader Struct2::Reader::getF0() const { - return ::capnp::AnyPointer::Reader(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder Struct2::Builder::getF0() { - return ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder Struct2::Builder::initF0() { - auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); - result.clear(); - return result; -} - -inline bool Struct2::Reader::hasF1i() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline bool Struct2::Builder::hasF1i() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -#if !CAPNP_LITE -inline ::Iface0::Client Struct2::Reader::getF1i() const { - return ::capnp::_::PointerHelpers< ::Iface0>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::Iface0::Client Struct2::Builder::getF1i() { - return ::capnp::_::PointerHelpers< ::Iface0>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::Iface0::Client Struct2::Pipeline::getF1i() { - return ::Iface0::Client(_typeless.getPointerField(1).asCap()); -} -inline void Struct2::Builder::setF1i( ::Iface0::Client&& cap) { - ::capnp::_::PointerHelpers< ::Iface0>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(cap)); -} -inline void Struct2::Builder::setF1i( ::Iface0::Client& cap) { - ::capnp::_::PointerHelpers< ::Iface0>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), cap); -} -inline void Struct2::Builder::adoptF1i( - ::capnp::Orphan< ::Iface0>&& value) { - ::capnp::_::PointerHelpers< ::Iface0>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::Iface0> Struct2::Builder::disownF1i() { - return ::capnp::_::PointerHelpers< ::Iface0>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -inline TestCap0::Client::Client(decltype(nullptr)) - : ::capnp::Capability::Client(nullptr) {} -inline TestCap0::Client::Client( - ::kj::Own< ::capnp::ClientHook>&& hook) - : ::capnp::Capability::Client(::kj::mv(hook)) {} -template -inline TestCap0::Client::Client(::kj::Own<_t>&& server) - : ::capnp::Capability::Client(::kj::mv(server)) {} -template -inline TestCap0::Client::Client(::kj::Promise<_t>&& promise) - : ::capnp::Capability::Client(::kj::mv(promise)) {} -inline TestCap0::Client::Client(::kj::Exception&& exception) - : ::capnp::Capability::Client(::kj::mv(exception)) {} -inline ::TestCap0::Client& TestCap0::Client::operator=(Client& other) { - ::capnp::Capability::Client::operator=(other); - return *this; -} -inline ::TestCap0::Client& TestCap0::Client::operator=(Client&& other) { - ::capnp::Capability::Client::operator=(kj::mv(other)); - return *this; -} - -#endif // !CAPNP_LITE -#if !CAPNP_LITE -inline TestCap1::Client::Client(decltype(nullptr)) - : ::capnp::Capability::Client(nullptr) {} -inline TestCap1::Client::Client( - ::kj::Own< ::capnp::ClientHook>&& hook) - : ::capnp::Capability::Client(::kj::mv(hook)) {} -template -inline TestCap1::Client::Client(::kj::Own<_t>&& server) - : ::capnp::Capability::Client(::kj::mv(server)) {} -template -inline TestCap1::Client::Client(::kj::Promise<_t>&& promise) - : ::capnp::Capability::Client(::kj::mv(promise)) {} -inline TestCap1::Client::Client(::kj::Exception&& exception) - : ::capnp::Capability::Client(::kj::mv(exception)) {} -inline ::TestCap1::Client& TestCap1::Client::operator=(Client& other) { - ::capnp::Capability::Client::operator=(other); - return *this; -} -inline ::TestCap1::Client& TestCap1::Client::operator=(Client&& other) { - ::capnp::Capability::Client::operator=(kj::mv(other)); - return *this; -} - -#endif // !CAPNP_LITE -#if !CAPNP_LITE -inline Iface1::Client::Client(decltype(nullptr)) - : ::capnp::Capability::Client(nullptr) {} -inline Iface1::Client::Client( - ::kj::Own< ::capnp::ClientHook>&& hook) - : ::capnp::Capability::Client(::kj::mv(hook)) {} -template -inline Iface1::Client::Client(::kj::Own<_t>&& server) - : ::capnp::Capability::Client(::kj::mv(server)) {} -template -inline Iface1::Client::Client(::kj::Promise<_t>&& promise) - : ::capnp::Capability::Client(::kj::mv(promise)) {} -inline Iface1::Client::Client(::kj::Exception&& exception) - : ::capnp::Capability::Client(::kj::mv(exception)) {} -inline ::Iface1::Client& Iface1::Client::operator=(Client& other) { - ::capnp::Capability::Client::operator=(other); - return *this; -} -inline ::Iface1::Client& Iface1::Client::operator=(Client&& other) { - ::capnp::Capability::Client::operator=(kj::mv(other)); - return *this; -} - -#endif // !CAPNP_LITE -inline bool Iface1::Struct1::Reader::getF0() const { - return _reader.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} - -inline bool Iface1::Struct1::Builder::getF0() { - return _builder.getDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS); -} -inline void Iface1::Struct1::Builder::setF0(bool value) { - _builder.setDataField( - ::capnp::bounded<0>() * ::capnp::ELEMENTS, value); -} - -inline bool Iface1::Struct1::Reader::hasF1() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline bool Iface1::Struct1::Builder::hasF1() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::capnp::AnyPointer::Reader Iface1::Struct1::Reader::getF1() const { - return ::capnp::AnyPointer::Reader(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder Iface1::Struct1::Builder::getF1() { - return ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::capnp::AnyPointer::Builder Iface1::Struct1::Builder::initF1() { - auto result = ::capnp::AnyPointer::Builder(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); - result.clear(); - return result; -} - -inline bool Iface1::Method0Results::Reader::hasResult0() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline bool Iface1::Method0Results::Builder::hasResult0() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline ::Struct0::Reader Iface1::Method0Results::Reader::getResult0() const { - return ::capnp::_::PointerHelpers< ::Struct0>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::Struct0::Builder Iface1::Method0Results::Builder::getResult0() { - return ::capnp::_::PointerHelpers< ::Struct0>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::Struct0::Pipeline Iface1::Method0Results::Pipeline::getResult0() { - return ::Struct0::Pipeline(_typeless.getPointerField(0)); -} -#endif // !CAPNP_LITE -inline void Iface1::Method0Results::Builder::setResult0( ::Struct0::Reader value) { - ::capnp::_::PointerHelpers< ::Struct0>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), value); -} -inline ::Struct0::Builder Iface1::Method0Results::Builder::initResult0() { - return ::capnp::_::PointerHelpers< ::Struct0>::init(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline void Iface1::Method0Results::Builder::adoptResult0( - ::capnp::Orphan< ::Struct0>&& value) { - ::capnp::_::PointerHelpers< ::Struct0>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::Struct0> Iface1::Method0Results::Builder::disownResult0() { - return ::capnp::_::PointerHelpers< ::Struct0>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} - -inline bool Iface1::Method0Results::Reader::hasResult1() const { - return !_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline bool Iface1::Method0Results::Builder::hasResult1() { - return !_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS).isNull(); -} -inline ::Iface1::Struct1::Reader Iface1::Method0Results::Reader::getResult1() const { - return ::capnp::_::PointerHelpers< ::Iface1::Struct1>::get(_reader.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline ::Iface1::Struct1::Builder Iface1::Method0Results::Builder::getResult1() { - return ::capnp::_::PointerHelpers< ::Iface1::Struct1>::get(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -#if !CAPNP_LITE -inline ::Iface1::Struct1::Pipeline Iface1::Method0Results::Pipeline::getResult1() { - return ::Iface1::Struct1::Pipeline(_typeless.getPointerField(1)); -} -#endif // !CAPNP_LITE -inline void Iface1::Method0Results::Builder::setResult1( ::Iface1::Struct1::Reader value) { - ::capnp::_::PointerHelpers< ::Iface1::Struct1>::set(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), value); -} -inline ::Iface1::Struct1::Builder Iface1::Method0Results::Builder::initResult1() { - return ::capnp::_::PointerHelpers< ::Iface1::Struct1>::init(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} -inline void Iface1::Method0Results::Builder::adoptResult1( - ::capnp::Orphan< ::Iface1::Struct1>&& value) { - ::capnp::_::PointerHelpers< ::Iface1::Struct1>::adopt(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::Iface1::Struct1> Iface1::Method0Results::Builder::disownResult1() { - return ::capnp::_::PointerHelpers< ::Iface1::Struct1>::disown(_builder.getPointerField( - ::capnp::bounded<1>() * ::capnp::POINTERS)); -} - -inline bool Iface1::Method1Results::Reader::hasResult0() const { - return !_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -inline bool Iface1::Method1Results::Builder::hasResult0() { - return !_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS).isNull(); -} -#if !CAPNP_LITE -inline ::Iface0::Client Iface1::Method1Results::Reader::getResult0() const { - return ::capnp::_::PointerHelpers< ::Iface0>::get(_reader.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::Iface0::Client Iface1::Method1Results::Builder::getResult0() { - return ::capnp::_::PointerHelpers< ::Iface0>::get(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -inline ::Iface0::Client Iface1::Method1Results::Pipeline::getResult0() { - return ::Iface0::Client(_typeless.getPointerField(0).asCap()); -} -inline void Iface1::Method1Results::Builder::setResult0( ::Iface0::Client&& cap) { - ::capnp::_::PointerHelpers< ::Iface0>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(cap)); -} -inline void Iface1::Method1Results::Builder::setResult0( ::Iface0::Client& cap) { - ::capnp::_::PointerHelpers< ::Iface0>::set(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), cap); -} -inline void Iface1::Method1Results::Builder::adoptResult0( - ::capnp::Orphan< ::Iface0>&& value) { - ::capnp::_::PointerHelpers< ::Iface0>::adopt(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value)); -} -inline ::capnp::Orphan< ::Iface0> Iface1::Method1Results::Builder::disownResult0() { - return ::capnp::_::PointerHelpers< ::Iface0>::disown(_builder.getPointerField( - ::capnp::bounded<0>() * ::capnp::POINTERS)); -} -#endif // !CAPNP_LITE - - diff --git a/runtime/src/test/java/org/capnproto/demo/democap.capnp b/runtime/src/test/java/org/capnproto/demo/democap.capnp deleted file mode 100644 index a195446..0000000 --- a/runtime/src/test/java/org/capnproto/demo/democap.capnp +++ /dev/null @@ -1,12 +0,0 @@ -@0xf29f4ba3b0a5a945; - -using Params = import "demoparams.capnp"; - -interface TestCap0 { - testMethod0 @0 Params.TestParams0 -> Params.TestResults0; - testMethod1 @1 Params.TestParams1 -> Params.TestResults1; -} - -interface TestCap1 { -} - diff --git a/runtime/src/test/java/org/capnproto/demo/democap.capnp.c++ b/runtime/src/test/java/org/capnproto/demo/democap.capnp.c++ deleted file mode 100644 index bcdec32..0000000 --- a/runtime/src/test/java/org/capnproto/demo/democap.capnp.c++ +++ /dev/null @@ -1,190 +0,0 @@ -// Generated by Cap'n Proto compiler, DO NOT EDIT -// source: democap.capnp - -#include "democap.capnp.h" - -namespace capnp { -namespace schemas { -static const ::capnp::_::AlignedData<40> b_a65f4a3d7f622e6b = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 107, 46, 98, 127, 61, 74, 95, 166, - 14, 0, 0, 0, 3, 0, 0, 0, - 69, 169, 165, 176, 163, 75, 159, 242, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 186, 0, 0, 0, - 29, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 25, 0, 0, 0, 135, 0, 0, 0, - 113, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 100, 101, 109, 111, 99, 97, 112, 46, - 99, 97, 112, 110, 112, 58, 84, 101, - 115, 116, 67, 97, 112, 48, 0, 0, - 0, 0, 0, 0, 1, 0, 1, 0, - 8, 0, 0, 0, 3, 0, 5, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 18, 240, 128, 209, 172, 180, 1, 179, - 129, 40, 181, 33, 84, 46, 164, 150, - 49, 0, 0, 0, 98, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 41, 0, 0, 0, 7, 0, 0, 0, - 1, 0, 0, 0, 0, 0, 0, 0, - 87, 9, 34, 182, 168, 99, 3, 225, - 62, 219, 93, 212, 228, 46, 133, 153, - 29, 0, 0, 0, 98, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 7, 0, 0, 0, - 116, 101, 115, 116, 77, 101, 116, 104, - 111, 100, 48, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1, 0, - 116, 101, 115, 116, 77, 101, 116, 104, - 111, 100, 49, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1, 0, - 0, 0, 0, 0, 1, 0, 1, 0, } -}; -::capnp::word const* const bp_a65f4a3d7f622e6b = b_a65f4a3d7f622e6b.words; -#if !CAPNP_LITE -static const ::capnp::_::RawSchema* const d_a65f4a3d7f622e6b[] = { - &s_96a42e5421b52881, - &s_99852ee4d45ddb3e, - &s_b301b4acd180f012, - &s_e10363a8b6220957, -}; -static const uint16_t m_a65f4a3d7f622e6b[] = {0, 1}; -const ::capnp::_::RawSchema s_a65f4a3d7f622e6b = { - 0xa65f4a3d7f622e6b, b_a65f4a3d7f622e6b.words, 40, d_a65f4a3d7f622e6b, m_a65f4a3d7f622e6b, - 4, 2, nullptr, nullptr, nullptr, { &s_a65f4a3d7f622e6b, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -static const ::capnp::_::AlignedData<18> b_81da3f8f6079c216 = { - { 0, 0, 0, 0, 5, 0, 6, 0, - 22, 194, 121, 96, 143, 63, 218, 129, - 14, 0, 0, 0, 3, 0, 0, 0, - 69, 169, 165, 176, 163, 75, 159, 242, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 21, 0, 0, 0, 186, 0, 0, 0, - 29, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 25, 0, 0, 0, 7, 0, 0, 0, - 25, 0, 0, 0, 7, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 100, 101, 109, 111, 99, 97, 112, 46, - 99, 97, 112, 110, 112, 58, 84, 101, - 115, 116, 67, 97, 112, 49, 0, 0, - 0, 0, 0, 0, 1, 0, 1, 0, - 0, 0, 0, 0, 3, 0, 5, 0, - 0, 0, 0, 0, 1, 0, 1, 0, } -}; -::capnp::word const* const bp_81da3f8f6079c216 = b_81da3f8f6079c216.words; -#if !CAPNP_LITE -const ::capnp::_::RawSchema s_81da3f8f6079c216 = { - 0x81da3f8f6079c216, b_81da3f8f6079c216.words, 18, nullptr, nullptr, - 0, 0, nullptr, nullptr, nullptr, { &s_81da3f8f6079c216, nullptr, nullptr, 0, 0, nullptr } -}; -#endif // !CAPNP_LITE -} // namespace schemas -} // namespace capnp - -// ======================================================================================= - - -#if !CAPNP_LITE -::capnp::Request< ::TestParams0, ::TestResults0> -TestCap0::Client::testMethod0Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) { - return newCall< ::TestParams0, ::TestResults0>( - 0xa65f4a3d7f622e6bull, 0, sizeHint); -} -::kj::Promise TestCap0::Server::testMethod0(TestMethod0Context) { - return ::capnp::Capability::Server::internalUnimplemented( - "democap.capnp:TestCap0", "testMethod0", - 0xa65f4a3d7f622e6bull, 0); -} -::capnp::Request< ::TestParams1, ::TestResults1> -TestCap0::Client::testMethod1Request(::kj::Maybe< ::capnp::MessageSize> sizeHint) { - return newCall< ::TestParams1, ::TestResults1>( - 0xa65f4a3d7f622e6bull, 1, sizeHint); -} -::kj::Promise TestCap0::Server::testMethod1(TestMethod1Context) { - return ::capnp::Capability::Server::internalUnimplemented( - "democap.capnp:TestCap0", "testMethod1", - 0xa65f4a3d7f622e6bull, 1); -} -::capnp::Capability::Server::DispatchCallResult TestCap0::Server::dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (interfaceId) { - case 0xa65f4a3d7f622e6bull: - return dispatchCallInternal(methodId, context); - default: - return internalUnimplemented("democap.capnp:TestCap0", interfaceId); - } -} -::capnp::Capability::Server::DispatchCallResult TestCap0::Server::dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (methodId) { - case 0: - return { - testMethod0(::capnp::Capability::Server::internalGetTypedContext< - ::TestParams0, ::TestResults0>(context)), - false - }; - case 1: - return { - testMethod1(::capnp::Capability::Server::internalGetTypedContext< - ::TestParams1, ::TestResults1>(context)), - false - }; - default: - (void)context; - return ::capnp::Capability::Server::internalUnimplemented( - "democap.capnp:TestCap0", - 0xa65f4a3d7f622e6bull, methodId); - } -} -#endif // !CAPNP_LITE - -// TestCap0 -#if !CAPNP_LITE -constexpr ::capnp::Kind TestCap0::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* TestCap0::_capnpPrivate::schema; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -::capnp::Capability::Server::DispatchCallResult TestCap1::Server::dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (interfaceId) { - case 0x81da3f8f6079c216ull: - return dispatchCallInternal(methodId, context); - default: - return internalUnimplemented("democap.capnp:TestCap1", interfaceId); - } -} -::capnp::Capability::Server::DispatchCallResult TestCap1::Server::dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) { - switch (methodId) { - default: - (void)context; - return ::capnp::Capability::Server::internalUnimplemented( - "democap.capnp:TestCap1", - 0x81da3f8f6079c216ull, methodId); - } -} -#endif // !CAPNP_LITE - -// TestCap1 -#if !CAPNP_LITE -constexpr ::capnp::Kind TestCap1::_capnpPrivate::kind; -constexpr ::capnp::_::RawSchema const* TestCap1::_capnpPrivate::schema; -#endif // !CAPNP_LITE - - - diff --git a/runtime/src/test/java/org/capnproto/demo/democap.capnp.h b/runtime/src/test/java/org/capnproto/demo/democap.capnp.h deleted file mode 100644 index b60b09e..0000000 --- a/runtime/src/test/java/org/capnproto/demo/democap.capnp.h +++ /dev/null @@ -1,216 +0,0 @@ -// Generated by Cap'n Proto compiler, DO NOT EDIT -// source: democap.capnp - -#pragma once - -#include -#include -#if !CAPNP_LITE -#include -#endif // !CAPNP_LITE - -#if CAPNP_VERSION != 8000 -#error "Version mismatch between generated code and library headers. You must use the same version of the Cap'n Proto compiler and library." -#endif - -#include "demoparams.capnp.h" - -namespace capnp { -namespace schemas { - -CAPNP_DECLARE_SCHEMA(a65f4a3d7f622e6b); -CAPNP_DECLARE_SCHEMA(81da3f8f6079c216); - -} // namespace schemas -} // namespace capnp - - -struct TestCap0 { - TestCap0() = delete; - -#if !CAPNP_LITE - class Client; - class Server; -#endif // !CAPNP_LITE - - - #if !CAPNP_LITE - struct _capnpPrivate { - CAPNP_DECLARE_INTERFACE_HEADER(a65f4a3d7f622e6b) - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - }; - #endif // !CAPNP_LITE -}; - -struct TestCap1 { - TestCap1() = delete; - -#if !CAPNP_LITE - class Client; - class Server; -#endif // !CAPNP_LITE - - - #if !CAPNP_LITE - struct _capnpPrivate { - CAPNP_DECLARE_INTERFACE_HEADER(81da3f8f6079c216) - static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; } - }; - #endif // !CAPNP_LITE -}; - -// ======================================================================================= - -#if !CAPNP_LITE -class TestCap0::Client - : public virtual ::capnp::Capability::Client { -public: - typedef TestCap0 Calls; - typedef TestCap0 Reads; - - Client(decltype(nullptr)); - explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); - template ()>> - Client(::kj::Own<_t>&& server); - template ()>> - Client(::kj::Promise<_t>&& promise); - Client(::kj::Exception&& exception); - Client(Client&) = default; - Client(Client&&) = default; - Client& operator=(Client& other); - Client& operator=(Client&& other); - - ::capnp::Request< ::TestParams0, ::TestResults0> testMethod0Request( - ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); - ::capnp::Request< ::TestParams1, ::TestResults1> testMethod1Request( - ::kj::Maybe< ::capnp::MessageSize> sizeHint = nullptr); - -protected: - Client() = default; -}; - -class TestCap0::Server - : public virtual ::capnp::Capability::Server { -public: - typedef TestCap0 Serves; - - ::capnp::Capability::Server::DispatchCallResult dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) - override; - -protected: - typedef ::capnp::CallContext< ::TestParams0, ::TestResults0> TestMethod0Context; - virtual ::kj::Promise testMethod0(TestMethod0Context context); - typedef ::capnp::CallContext< ::TestParams1, ::TestResults1> TestMethod1Context; - virtual ::kj::Promise testMethod1(TestMethod1Context context); - - inline ::TestCap0::Client thisCap() { - return ::capnp::Capability::Server::thisCap() - .template castAs< ::TestCap0>(); - } - - ::capnp::Capability::Server::DispatchCallResult dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); -}; -#endif // !CAPNP_LITE - -#if !CAPNP_LITE -class TestCap1::Client - : public virtual ::capnp::Capability::Client { -public: - typedef TestCap1 Calls; - typedef TestCap1 Reads; - - Client(decltype(nullptr)); - explicit Client(::kj::Own< ::capnp::ClientHook>&& hook); - template ()>> - Client(::kj::Own<_t>&& server); - template ()>> - Client(::kj::Promise<_t>&& promise); - Client(::kj::Exception&& exception); - Client(Client&) = default; - Client(Client&&) = default; - Client& operator=(Client& other); - Client& operator=(Client&& other); - - -protected: - Client() = default; -}; - -class TestCap1::Server - : public virtual ::capnp::Capability::Server { -public: - typedef TestCap1 Serves; - - ::capnp::Capability::Server::DispatchCallResult dispatchCall( - uint64_t interfaceId, uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context) - override; - -protected: - - inline ::TestCap1::Client thisCap() { - return ::capnp::Capability::Server::thisCap() - .template castAs< ::TestCap1>(); - } - - ::capnp::Capability::Server::DispatchCallResult dispatchCallInternal( - uint16_t methodId, - ::capnp::CallContext< ::capnp::AnyPointer, ::capnp::AnyPointer> context); -}; -#endif // !CAPNP_LITE - -// ======================================================================================= - -#if !CAPNP_LITE -inline TestCap0::Client::Client(decltype(nullptr)) - : ::capnp::Capability::Client(nullptr) {} -inline TestCap0::Client::Client( - ::kj::Own< ::capnp::ClientHook>&& hook) - : ::capnp::Capability::Client(::kj::mv(hook)) {} -template -inline TestCap0::Client::Client(::kj::Own<_t>&& server) - : ::capnp::Capability::Client(::kj::mv(server)) {} -template -inline TestCap0::Client::Client(::kj::Promise<_t>&& promise) - : ::capnp::Capability::Client(::kj::mv(promise)) {} -inline TestCap0::Client::Client(::kj::Exception&& exception) - : ::capnp::Capability::Client(::kj::mv(exception)) {} -inline ::TestCap0::Client& TestCap0::Client::operator=(Client& other) { - ::capnp::Capability::Client::operator=(other); - return *this; -} -inline ::TestCap0::Client& TestCap0::Client::operator=(Client&& other) { - ::capnp::Capability::Client::operator=(kj::mv(other)); - return *this; -} - -#endif // !CAPNP_LITE -#if !CAPNP_LITE -inline TestCap1::Client::Client(decltype(nullptr)) - : ::capnp::Capability::Client(nullptr) {} -inline TestCap1::Client::Client( - ::kj::Own< ::capnp::ClientHook>&& hook) - : ::capnp::Capability::Client(::kj::mv(hook)) {} -template -inline TestCap1::Client::Client(::kj::Own<_t>&& server) - : ::capnp::Capability::Client(::kj::mv(server)) {} -template -inline TestCap1::Client::Client(::kj::Promise<_t>&& promise) - : ::capnp::Capability::Client(::kj::mv(promise)) {} -inline TestCap1::Client::Client(::kj::Exception&& exception) - : ::capnp::Capability::Client(::kj::mv(exception)) {} -inline ::TestCap1::Client& TestCap1::Client::operator=(Client& other) { - ::capnp::Capability::Client::operator=(other); - return *this; -} -inline ::TestCap1::Client& TestCap1::Client::operator=(Client&& other) { - ::capnp::Capability::Client::operator=(kj::mv(other)); - return *this; -} - -#endif // !CAPNP_LITE - diff --git a/runtime/src/test/java/org/capnproto/demo/demoparams.capnp b/runtime/src/test/java/org/capnproto/demo/demoparams.capnp deleted file mode 100644 index 560cad4..0000000 --- a/runtime/src/test/java/org/capnproto/demo/demoparams.capnp +++ /dev/null @@ -1,25 +0,0 @@ -@0x91b57797d64253c4; - -using Java = import "/capnp/java.capnp"; -$Java.package("org.capnproto.demo"); -$Java.outerClassname("Demo"); - -struct TestParams0 { - param0 @0 :Int32; -} - -struct TestResults0 { - result0 @0 :Int32; -} - -struct TestParams1 { - param0 @0 :AnyPointer; -} - -struct TestResults1 { - result0 @0 :AnyPointer; - result1 @1 :AnyPointer; - result2 @2 :AnyPointer; -} - -