From 1ec5ff7b1443e4b205b953875fd876fd6e76fce0 Mon Sep 17 00:00:00 2001
From: pans <pans@454eff88-639b-444f-9e54-f578c98de674>
Date: 星期三, 09 八月 2017 12:22:33 +0800
Subject: [PATCH] capnproto update to 7.0dev
---
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-json.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/arena.h | 496 ++
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-0.7-dev.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-0.7-dev.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc-0.7-dev.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/catrank.capnp | 35
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/parser.h | 151
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/node-translator.h | 323 +
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/thread.h | 3
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/readiness-io.h | 92
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj-0.7-dev.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/exception.h | 8
VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/common.h | 297 +
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/type-id.h | 45
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/parse/char.h | 7
VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/protobuf-common.h | 359 +
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/error-reporter.h | 97
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/tls.h | 226 +
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc-0.7-dev.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/array.h | 23
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/filesystem.h | 923 ++++
VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/null-common.h | 174
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/mutex.h | 48
VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/capnproto-common.h | 423 +
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/vector.h | 17
VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/eval.capnp | 51
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/grammar.capnp.h | 6837 +++++++++++++++++++++++++++++++
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/miniposix.h | 152
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/one-of.h | 26
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/common.h | 63
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj-0.7-dev.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/lexer.h | 102
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-json-0.7-dev.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-json.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/test-util.h | 312 +
/dev/null | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/carsales.capnp | 80
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/http.h | 6
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/lexer.capnp.h | 1242 +++++
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/module-loader.h | 65
VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-json-0.7-dev.so | 0
VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/compiler.h | 204
48 files changed, 12,875 insertions(+), 12 deletions(-)
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/capnproto-common.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/capnproto-common.h
new file mode 100644
index 0000000..1705f91
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/capnproto-common.h
@@ -0,0 +1,423 @@
+// 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.
+
+#ifndef CAPNP_BENCHMARK_CAPNP_COMMON_H_
+#define CAPNP_BENCHMARK_CAPNP_COMMON_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include "common.h"
+#include <capnp/serialize.h>
+#include <capnp/serialize-packed.h>
+#include <kj/debug.h>
+#if HAVE_SNAPPY
+#include <capnp/serialize-snappy.h>
+#endif // HAVE_SNAPPY
+#include <thread>
+
+namespace capnp {
+namespace benchmark {
+namespace capnp {
+
+class CountingOutputStream: public kj::FdOutputStream {
+public:
+ CountingOutputStream(int fd): FdOutputStream(fd), throughput(0) {}
+
+ uint64_t throughput;
+
+ void write(const void* buffer, size_t size) override {
+ FdOutputStream::write(buffer, size);
+ throughput += size;
+ }
+
+ void write(kj::ArrayPtr<const kj::ArrayPtr<const byte>> pieces) override {
+ FdOutputStream::write(pieces);
+ for (auto& piece: pieces) {
+ throughput += piece.size();
+ }
+ }
+};
+
+// =======================================================================================
+
+struct Uncompressed {
+ typedef kj::FdInputStream& BufferedInput;
+ typedef InputStreamMessageReader MessageReader;
+
+ class ArrayMessageReader: public FlatArrayMessageReader {
+ public:
+ ArrayMessageReader(kj::ArrayPtr<const byte> array,
+ ReaderOptions options = ReaderOptions(),
+ kj::ArrayPtr<word> scratchSpace = nullptr)
+ : FlatArrayMessageReader(kj::arrayPtr(
+ reinterpret_cast<const word*>(array.begin()),
+ reinterpret_cast<const word*>(array.end())), options) {}
+ };
+
+ static inline void write(kj::OutputStream& output, MessageBuilder& builder) {
+ writeMessage(output, builder);
+ }
+};
+
+struct Packed {
+ typedef kj::BufferedInputStreamWrapper BufferedInput;
+ typedef PackedMessageReader MessageReader;
+
+ class ArrayMessageReader: private kj::ArrayInputStream, public PackedMessageReader {
+ public:
+ ArrayMessageReader(kj::ArrayPtr<const byte> array,
+ ReaderOptions options = ReaderOptions(),
+ kj::ArrayPtr<word> scratchSpace = nullptr)
+ : ArrayInputStream(array),
+ PackedMessageReader(*this, options, scratchSpace) {}
+ };
+
+ static inline void write(kj::OutputStream& output, MessageBuilder& builder) {
+ writePackedMessage(output, builder);
+ }
+
+ static inline void write(kj::BufferedOutputStream& output, MessageBuilder& builder) {
+ writePackedMessage(output, builder);
+ }
+};
+
+#if HAVE_SNAPPY
+static byte snappyReadBuffer[SNAPPY_BUFFER_SIZE];
+static byte snappyWriteBuffer[SNAPPY_BUFFER_SIZE];
+static byte snappyCompressedBuffer[SNAPPY_COMPRESSED_BUFFER_SIZE];
+
+struct SnappyCompressed {
+ typedef BufferedInputStreamWrapper BufferedInput;
+ typedef SnappyPackedMessageReader MessageReader;
+
+ class ArrayMessageReader: private ArrayInputStream, public SnappyPackedMessageReader {
+ public:
+ ArrayMessageReader(kj::ArrayPtr<const byte> array,
+ ReaderOptions options = ReaderOptions(),
+ kj::ArrayPtr<word> scratchSpace = nullptr)
+ : ArrayInputStream(array),
+ SnappyPackedMessageReader(static_cast<ArrayInputStream&>(*this), options, scratchSpace,
+ kj::arrayPtr(snappyReadBuffer, SNAPPY_BUFFER_SIZE)) {}
+ };
+
+ static inline void write(OutputStream& output, MessageBuilder& builder) {
+ writeSnappyPackedMessage(output, builder,
+ kj::arrayPtr(snappyWriteBuffer, SNAPPY_BUFFER_SIZE),
+ kj::arrayPtr(snappyCompressedBuffer, SNAPPY_COMPRESSED_BUFFER_SIZE));
+ }
+};
+#endif // HAVE_SNAPPY
+
+// =======================================================================================
+
+struct NoScratch {
+ struct ScratchSpace {};
+
+ template <typename Compression>
+ class MessageReader: public Compression::MessageReader {
+ public:
+ inline MessageReader(typename Compression::BufferedInput& input, ScratchSpace& scratch)
+ : Compression::MessageReader(input) {}
+ };
+
+ template <typename Compression>
+ class ArrayMessageReader: public Compression::ArrayMessageReader {
+ public:
+ inline ArrayMessageReader(kj::ArrayPtr<const byte> input, ScratchSpace& scratch)
+ : Compression::ArrayMessageReader(input) {}
+ };
+
+ class MessageBuilder: public MallocMessageBuilder {
+ public:
+ inline MessageBuilder(ScratchSpace& scratch): MallocMessageBuilder() {}
+ };
+
+ class ObjectSizeCounter {
+ public:
+ ObjectSizeCounter(uint64_t iters): counter(0) {}
+
+ template <typename RequestBuilder, typename ResponseBuilder>
+ void add(RequestBuilder& request, ResponseBuilder& response) {
+ for (auto segment: request.getSegmentsForOutput()) {
+ counter += segment.size() * sizeof(word);
+ }
+ for (auto segment: response.getSegmentsForOutput()) {
+ counter += segment.size() * sizeof(word);
+ }
+ }
+
+ uint64_t get() { return counter; }
+
+ private:
+ uint64_t counter;
+ };
+};
+
+constexpr size_t SCRATCH_SIZE = 128 * 1024;
+word scratchSpace[6 * SCRATCH_SIZE];
+int scratchCounter = 0;
+
+struct UseScratch {
+ struct ScratchSpace {
+ word* words;
+
+ ScratchSpace() {
+ KJ_REQUIRE(scratchCounter < 6, "Too many scratch spaces needed at once.");
+ words = scratchSpace + scratchCounter++ * SCRATCH_SIZE;
+ }
+ ~ScratchSpace() noexcept {
+ --scratchCounter;
+ }
+ };
+
+ template <typename Compression>
+ class MessageReader: public Compression::MessageReader {
+ public:
+ inline MessageReader(typename Compression::BufferedInput& input, ScratchSpace& scratch)
+ : Compression::MessageReader(
+ input, ReaderOptions(), kj::arrayPtr(scratch.words, SCRATCH_SIZE)) {}
+ };
+
+ template <typename Compression>
+ class ArrayMessageReader: public Compression::ArrayMessageReader {
+ public:
+ inline ArrayMessageReader(kj::ArrayPtr<const byte> input, ScratchSpace& scratch)
+ : Compression::ArrayMessageReader(
+ input, ReaderOptions(), kj::arrayPtr(scratch.words, SCRATCH_SIZE)) {}
+ };
+
+ class MessageBuilder: public MallocMessageBuilder {
+ public:
+ inline MessageBuilder(ScratchSpace& scratch)
+ : MallocMessageBuilder(kj::arrayPtr(scratch.words, SCRATCH_SIZE)) {}
+ };
+
+ class ObjectSizeCounter {
+ public:
+ ObjectSizeCounter(uint64_t iters): iters(iters), maxSize(0) {}
+
+ template <typename RequestBuilder, typename ResponseBuilder>
+ void add(RequestBuilder& request, ResponseBuilder& response) {
+ size_t counter = 0;
+ for (auto segment: request.getSegmentsForOutput()) {
+ counter += segment.size() * sizeof(word);
+ }
+ for (auto segment: response.getSegmentsForOutput()) {
+ counter += segment.size() * sizeof(word);
+ }
+ maxSize = std::max(counter, maxSize);
+ }
+
+ uint64_t get() { return iters * maxSize; }
+
+ private:
+ uint64_t iters;
+ size_t maxSize;
+ };
+};
+
+// =======================================================================================
+
+template <typename TestCase, typename ReuseStrategy, typename Compression>
+struct BenchmarkMethods {
+ static uint64_t syncClient(int inputFd, int outputFd, uint64_t iters) {
+ kj::FdInputStream inputStream(inputFd);
+ typename Compression::BufferedInput bufferedInput(inputStream);
+
+ CountingOutputStream output(outputFd);
+ typename ReuseStrategy::ScratchSpace builderScratch;
+ typename ReuseStrategy::ScratchSpace readerScratch;
+
+ for (; iters > 0; --iters) {
+ typename TestCase::Expectation expected;
+ {
+ typename ReuseStrategy::MessageBuilder builder(builderScratch);
+ expected = TestCase::setupRequest(
+ builder.template initRoot<typename TestCase::Request>());
+ Compression::write(output, builder);
+ }
+
+ {
+ typename ReuseStrategy::template MessageReader<Compression> reader(
+ bufferedInput, readerScratch);
+ if (!TestCase::checkResponse(
+ reader.template getRoot<typename TestCase::Response>(), expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+ }
+ }
+
+ return output.throughput;
+ }
+
+ static uint64_t asyncClientSender(
+ int outputFd, ProducerConsumerQueue<typename TestCase::Expectation>* expectations,
+ uint64_t iters) {
+ CountingOutputStream output(outputFd);
+ typename ReuseStrategy::ScratchSpace scratch;
+
+ for (; iters > 0; --iters) {
+ typename ReuseStrategy::MessageBuilder builder(scratch);
+ expectations->post(TestCase::setupRequest(
+ builder.template initRoot<typename TestCase::Request>()));
+ Compression::write(output, builder);
+ }
+
+ return output.throughput;
+ }
+
+ static void asyncClientReceiver(
+ int inputFd, ProducerConsumerQueue<typename TestCase::Expectation>* expectations,
+ uint64_t iters) {
+ kj::FdInputStream inputStream(inputFd);
+ typename Compression::BufferedInput bufferedInput(inputStream);
+
+ typename ReuseStrategy::ScratchSpace scratch;
+
+ for (; iters > 0; --iters) {
+ typename TestCase::Expectation expected = expectations->next();
+ typename ReuseStrategy::template MessageReader<Compression> reader(bufferedInput, scratch);
+ if (!TestCase::checkResponse(
+ reader.template getRoot<typename TestCase::Response>(), expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+ }
+ }
+
+ static uint64_t asyncClient(int inputFd, int outputFd, uint64_t iters) {
+ ProducerConsumerQueue<typename TestCase::Expectation> expectations;
+ std::thread receiverThread(asyncClientReceiver, inputFd, &expectations, iters);
+ uint64_t throughput = asyncClientSender(outputFd, &expectations, iters);
+ receiverThread.join();
+ return throughput;
+ }
+
+ static uint64_t server(int inputFd, int outputFd, uint64_t iters) {
+ kj::FdInputStream inputStream(inputFd);
+ typename Compression::BufferedInput bufferedInput(inputStream);
+
+ CountingOutputStream output(outputFd);
+ typename ReuseStrategy::ScratchSpace builderScratch;
+ typename ReuseStrategy::ScratchSpace readerScratch;
+
+ for (; iters > 0; --iters) {
+ typename ReuseStrategy::MessageBuilder builder(builderScratch);
+ typename ReuseStrategy::template MessageReader<Compression> reader(
+ bufferedInput, readerScratch);
+ TestCase::handleRequest(reader.template getRoot<typename TestCase::Request>(),
+ builder.template initRoot<typename TestCase::Response>());
+ Compression::write(output, builder);
+ }
+
+ return output.throughput;
+ }
+
+ static uint64_t passByObject(uint64_t iters, bool countObjectSize) {
+ typename ReuseStrategy::ScratchSpace requestScratch;
+ typename ReuseStrategy::ScratchSpace responseScratch;
+
+ typename ReuseStrategy::ObjectSizeCounter counter(iters);
+
+ for (; iters > 0; --iters) {
+ typename ReuseStrategy::MessageBuilder requestMessage(requestScratch);
+ auto request = requestMessage.template initRoot<typename TestCase::Request>();
+ typename TestCase::Expectation expected = TestCase::setupRequest(request);
+
+ typename ReuseStrategy::MessageBuilder responseMessage(responseScratch);
+ auto response = responseMessage.template initRoot<typename TestCase::Response>();
+ TestCase::handleRequest(request.asReader(), response);
+
+ if (!TestCase::checkResponse(response.asReader(), expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+
+ if (countObjectSize) {
+ counter.add(requestMessage, responseMessage);
+ }
+ }
+
+ return counter.get();
+ }
+
+ static uint64_t passByBytes(uint64_t iters) {
+ uint64_t throughput = 0;
+ typename ReuseStrategy::ScratchSpace clientRequestScratch;
+ UseScratch::ScratchSpace requestBytesScratch;
+ typename ReuseStrategy::ScratchSpace serverRequestScratch;
+ typename ReuseStrategy::ScratchSpace serverResponseScratch;
+ UseScratch::ScratchSpace responseBytesScratch;
+ typename ReuseStrategy::ScratchSpace clientResponseScratch;
+
+ for (; iters > 0; --iters) {
+ typename ReuseStrategy::MessageBuilder requestBuilder(clientRequestScratch);
+ typename TestCase::Expectation expected = TestCase::setupRequest(
+ requestBuilder.template initRoot<typename TestCase::Request>());
+
+ kj::ArrayOutputStream requestOutput(kj::arrayPtr(
+ reinterpret_cast<byte*>(requestBytesScratch.words), SCRATCH_SIZE * sizeof(word)));
+ Compression::write(requestOutput, requestBuilder);
+ throughput += requestOutput.getArray().size();
+ typename ReuseStrategy::template ArrayMessageReader<Compression> requestReader(
+ requestOutput.getArray(), serverRequestScratch);
+
+ typename ReuseStrategy::MessageBuilder responseBuilder(serverResponseScratch);
+ TestCase::handleRequest(requestReader.template getRoot<typename TestCase::Request>(),
+ responseBuilder.template initRoot<typename TestCase::Response>());
+
+ kj::ArrayOutputStream responseOutput(
+ kj::arrayPtr(reinterpret_cast<byte*>(responseBytesScratch.words),
+ SCRATCH_SIZE * sizeof(word)));
+ Compression::write(responseOutput, responseBuilder);
+ throughput += responseOutput.getArray().size();
+ typename ReuseStrategy::template ArrayMessageReader<Compression> responseReader(
+ responseOutput.getArray(), clientResponseScratch);
+
+ if (!TestCase::checkResponse(
+ responseReader.template getRoot<typename TestCase::Response>(), expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+ }
+
+ return throughput;
+ }
+};
+
+struct BenchmarkTypes {
+ typedef capnp::Uncompressed Uncompressed;
+ typedef capnp::Packed Packed;
+#if HAVE_SNAPPY
+ typedef capnp::SnappyCompressed SnappyCompressed;
+#endif // HAVE_SNAPPY
+
+ typedef capnp::UseScratch ReusableResources;
+ typedef capnp::NoScratch SingleUseResources;
+
+ template <typename TestCase, typename ReuseStrategy, typename Compression>
+ struct BenchmarkMethods: public capnp::BenchmarkMethods<TestCase, ReuseStrategy, Compression> {};
+};
+
+} // namespace capnp
+} // namespace benchmark
+} // namespace capnp
+
+#endif // CAPNP_BENCHMARK_CAPNP_COMMON_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/carsales.capnp b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/carsales.capnp
new file mode 100644
index 0000000..075cae5
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/carsales.capnp
@@ -0,0 +1,80 @@
+# 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.
+
+using Cxx = import "/capnp/c++.capnp";
+
+@0xff75ddc6a36723c9;
+$Cxx.namespace("capnp::benchmark::capnp");
+
+struct ParkingLot {
+ cars@0: List(Car);
+}
+
+struct TotalValue {
+ amount@0: UInt64;
+}
+
+struct Car {
+ make@0: Text;
+ model@1: Text;
+ color@2: Color;
+ seats@3: UInt8;
+ doors@4: UInt8;
+ wheels@5: List(Wheel);
+ length@6: UInt16;
+ width@7: UInt16;
+ height@8: UInt16;
+ weight@9: UInt32;
+ engine@10: Engine;
+ fuelCapacity@11: Float32;
+ fuelLevel@12: Float32;
+ hasPowerWindows@13: Bool;
+ hasPowerSteering@14: Bool;
+ hasCruiseControl@15: Bool;
+ cupHolders@16: UInt8;
+ hasNavSystem@17: Bool;
+}
+
+enum Color {
+ black @0;
+ white @1;
+ red @2;
+ green @3;
+ blue @4;
+ cyan @5;
+ magenta @6;
+ yellow @7;
+ silver @8;
+}
+
+struct Wheel {
+ diameter@0: UInt16;
+ airPressure@1: Float32;
+ snowTires@2: Bool;
+}
+
+struct Engine {
+ horsepower@0: UInt16;
+ cylinders@1: UInt8;
+ cc@2: UInt32;
+ usesGas@3: Bool;
+ usesElectric@4: Bool;
+}
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/catrank.capnp b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/catrank.capnp
new file mode 100644
index 0000000..7ec754a
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/catrank.capnp
@@ -0,0 +1,35 @@
+# 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.
+
+using Cxx = import "/capnp/c++.capnp";
+
+@0x82beb8e37ff79aba;
+$Cxx.namespace("capnp::benchmark::capnp");
+
+struct SearchResultList {
+ results@0: List(SearchResult);
+}
+
+struct SearchResult {
+ url@0: Text;
+ score@1: Float64;
+ snippet@2: Text;
+}
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/common.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/common.h
new file mode 100644
index 0000000..aa3ac3c
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/common.h
@@ -0,0 +1,297 @@
+// 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.
+
+#ifndef CAPNP_BENCHMARK_COMMON_H_
+#define CAPNP_BENCHMARK_COMMON_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include <unistd.h>
+#include <limits>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+#include <semaphore.h>
+#include <algorithm>
+#include <stdexcept>
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <vector>
+
+namespace capnp {
+namespace benchmark {
+
+// Use a 128-bit Xorshift algorithm.
+static inline uint32_t nextFastRand() {
+ // These values are arbitrary. Any seed other than all zeroes is OK.
+ static uint32_t x = 0x1d2acd47;
+ static uint32_t y = 0x58ca3e14;
+ static uint32_t z = 0xf563f232;
+ static uint32_t w = 0x0bc76199;
+
+ uint32_t tmp = x ^ (x << 11);
+ x = y;
+ y = z;
+ z = w;
+ w = w ^ (w >> 19) ^ tmp ^ (tmp >> 8);
+ return w;
+}
+
+static inline uint32_t fastRand(uint32_t range) {
+ return nextFastRand() % range;
+}
+
+static inline double fastRandDouble(double range) {
+ return nextFastRand() * range / std::numeric_limits<uint32_t>::max();
+}
+
+inline int32_t div(int32_t a, int32_t b) {
+ if (b == 0) return std::numeric_limits<int32_t>::max();
+ // INT_MIN / -1 => SIGFPE. Who knew?
+ if (a == std::numeric_limits<int32_t>::min() && b == -1) {
+ return std::numeric_limits<int32_t>::max();
+ }
+ return a / b;
+}
+
+inline int32_t mod(int32_t a, int32_t b) {
+ if (b == 0) return std::numeric_limits<int32_t>::max();
+ // INT_MIN % -1 => SIGFPE. Who knew?
+ if (a == std::numeric_limits<int32_t>::min() && b == -1) {
+ return std::numeric_limits<int32_t>::max();
+ }
+ return a % b;
+}
+
+static const char* const WORDS[] = {
+ "foo ", "bar ", "baz ", "qux ", "quux ", "corge ", "grault ", "garply ", "waldo ", "fred ",
+ "plugh ", "xyzzy ", "thud "
+};
+constexpr size_t WORDS_COUNT = sizeof(WORDS) / sizeof(WORDS[0]);
+
+template <typename T>
+class ProducerConsumerQueue {
+public:
+ ProducerConsumerQueue() {
+ front = new Node;
+ back = front;
+ sem_init(&semaphore, 0, 0);
+ }
+
+ ~ProducerConsumerQueue() noexcept(false) {
+ while (front != nullptr) {
+ Node* oldFront = front;
+ front = front->next;
+ delete oldFront;
+ }
+ sem_destroy(&semaphore);
+ }
+
+ void post(T t) {
+ back->next = new Node(t);
+ back = back->next;
+ sem_post(&semaphore);
+ }
+
+ T next() {
+ sem_wait(&semaphore);
+ Node* oldFront = front;
+ front = front->next;
+ delete oldFront;
+ return front->value;
+ }
+
+private:
+ struct Node {
+ T value;
+ Node* next;
+
+ Node(): next(nullptr) {}
+ Node(T value): value(value), next(nullptr) {}
+ };
+
+ Node* front; // Last node that has been consumed.
+ Node* back; // Last node in list.
+ sem_t semaphore;
+};
+
+// TODO(cleanup): Use SYSCALL(), get rid of this exception class.
+class OsException: public std::exception {
+public:
+ OsException(int error): error(error) {}
+ ~OsException() noexcept {}
+
+ const char* what() const noexcept override {
+ return strerror(error);
+ }
+
+private:
+ int error;
+};
+
+static void writeAll(int fd, const void* buffer, size_t size) {
+ const char* pos = reinterpret_cast<const char*>(buffer);
+ while (size > 0) {
+ ssize_t n = write(fd, pos, size);
+ if (n <= 0) {
+ throw OsException(errno);
+ }
+ pos += n;
+ size -= n;
+ }
+}
+
+static void readAll(int fd, void* buffer, size_t size) {
+ char* pos = reinterpret_cast<char*>(buffer);
+ while (size > 0) {
+ ssize_t n = read(fd, pos, size);
+ if (n <= 0) {
+ throw OsException(errno);
+ }
+ pos += n;
+ size -= n;
+ }
+}
+
+template <typename BenchmarkMethods, typename Func>
+uint64_t passByPipe(Func&& clientFunc, uint64_t iters) {
+ int clientToServer[2];
+ int serverToClient[2];
+ if (pipe(clientToServer) < 0) throw OsException(errno);
+ if (pipe(serverToClient) < 0) throw OsException(errno);
+
+ pid_t child = fork();
+ if (child == 0) {
+ // Client.
+ close(clientToServer[0]);
+ close(serverToClient[1]);
+
+ uint64_t throughput = clientFunc(serverToClient[0], clientToServer[1], iters);
+ writeAll(clientToServer[1], &throughput, sizeof(throughput));
+
+ exit(0);
+ } else {
+ // Server.
+ close(clientToServer[1]);
+ close(serverToClient[0]);
+
+ uint64_t throughput = BenchmarkMethods::server(clientToServer[0], serverToClient[1], iters);
+
+ uint64_t clientThroughput = 0;
+ readAll(clientToServer[0], &clientThroughput, sizeof(clientThroughput));
+ throughput += clientThroughput;
+
+ int status;
+ if (waitpid(child, &status, 0) != child) {
+ throw OsException(errno);
+ }
+ if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+ throw std::logic_error("Child exited abnormally.");
+ }
+
+ return throughput;
+ }
+}
+
+template <typename BenchmarkTypes, typename TestCase, typename Reuse, typename Compression>
+uint64_t doBenchmark(const std::string& mode, uint64_t iters) {
+ typedef typename BenchmarkTypes::template BenchmarkMethods<TestCase, Reuse, Compression>
+ BenchmarkMethods;
+ if (mode == "client") {
+ return BenchmarkMethods::syncClient(STDIN_FILENO, STDOUT_FILENO, iters);
+ } else if (mode == "server") {
+ return BenchmarkMethods::server(STDIN_FILENO, STDOUT_FILENO, iters);
+ } else if (mode == "object") {
+ return BenchmarkMethods::passByObject(iters, false);
+ } else if (mode == "object-size") {
+ return BenchmarkMethods::passByObject(iters, true);
+ } else if (mode == "bytes") {
+ return BenchmarkMethods::passByBytes(iters);
+ } else if (mode == "pipe") {
+ return passByPipe<BenchmarkMethods>(BenchmarkMethods::syncClient, iters);
+ } else if (mode == "pipe-async") {
+ return passByPipe<BenchmarkMethods>(BenchmarkMethods::asyncClient, iters);
+ } else {
+ fprintf(stderr, "Unknown mode: %s\n", mode.c_str());
+ exit(1);
+ }
+}
+
+template <typename BenchmarkTypes, typename TestCase, typename Compression>
+uint64_t doBenchmark2(const std::string& mode, const std::string& reuse, uint64_t iters) {
+ if (reuse == "reuse") {
+ return doBenchmark<
+ BenchmarkTypes, TestCase, typename BenchmarkTypes::ReusableResources, Compression>(
+ mode, iters);
+ } else if (reuse == "no-reuse") {
+ return doBenchmark<
+ BenchmarkTypes, TestCase, typename BenchmarkTypes::SingleUseResources, Compression>(
+ mode, iters);
+ } else {
+ fprintf(stderr, "Unknown reuse mode: %s\n", reuse.c_str());
+ exit(1);
+ }
+}
+
+template <typename BenchmarkTypes, typename TestCase>
+uint64_t doBenchmark3(const std::string& mode, const std::string& reuse,
+ const std::string& compression, uint64_t iters) {
+ if (compression == "none") {
+ return doBenchmark2<BenchmarkTypes, TestCase, typename BenchmarkTypes::Uncompressed>(
+ mode, reuse, iters);
+ } else if (compression == "packed") {
+ return doBenchmark2<BenchmarkTypes, TestCase, typename BenchmarkTypes::Packed>(
+ mode, reuse, iters);
+#if HAVE_SNAPPY
+ } else if (compression == "snappy") {
+ return doBenchmark2<BenchmarkTypes, TestCase, typename BenchmarkTypes::SnappyCompressed>(
+ mode, reuse, iters);
+#endif // HAVE_SNAPPY
+ } else {
+ fprintf(stderr, "Unknown compression mode: %s\n", compression.c_str());
+ exit(1);
+ }
+}
+
+template <typename BenchmarkTypes, typename TestCase>
+int benchmarkMain(int argc, char* argv[]) {
+ if (argc != 5) {
+ fprintf(stderr, "USAGE: %s MODE REUSE COMPRESSION ITERATION_COUNT\n", argv[0]);
+ return 1;
+ }
+
+ uint64_t iters = strtoull(argv[4], nullptr, 0);
+ uint64_t throughput = doBenchmark3<BenchmarkTypes, TestCase>(argv[1], argv[2], argv[3], iters);
+ fprintf(stdout, "%llu\n", (long long unsigned int)throughput);
+
+ return 0;
+}
+
+} // namespace capnp
+} // namespace benchmark
+
+#endif // CAPNP_BENCHMARK_COMMON_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/eval.capnp b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/eval.capnp
new file mode 100644
index 0000000..fe9a8d4
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/eval.capnp
@@ -0,0 +1,51 @@
+# 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.
+
+using Cxx = import "/capnp/c++.capnp";
+
+@0xe12dc4c3e70e9eda;
+$Cxx.namespace("capnp::benchmark::capnp");
+
+enum Operation {
+ add @0;
+ subtract @1;
+ multiply @2;
+ divide @3;
+ modulus @4;
+}
+
+struct Expression {
+ op@0: Operation;
+
+ left :union {
+ value@1: Int32;
+ expression@2: Expression;
+ }
+
+ right :union {
+ value@3: Int32;
+ expression@4: Expression;
+ }
+}
+
+struct EvaluationResult {
+ value@0: Int32;
+}
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/null-common.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/null-common.h
new file mode 100644
index 0000000..3c26919
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/null-common.h
@@ -0,0 +1,174 @@
+// 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.
+
+#include "common.h"
+
+namespace capnp {
+namespace benchmark {
+namespace null {
+
+uint64_t arena[1024*1024];
+uint64_t* arenaPos = arena;
+
+template <typename T>
+T* allocate(int count = 1) {
+ T* result = reinterpret_cast<T*>(arenaPos);
+ arenaPos += (sizeof(T) * count + 7) / 8;
+ if (arenaPos > arena + sizeof(arena) / sizeof(arena[0])) {
+ throw std::bad_alloc();
+ }
+ return result;
+}
+
+char* copyString(const char* str) {
+ size_t len = strlen(str);
+ char* result = allocate<char>(len);
+ memcpy(result, str, len + 1);
+ return result;
+}
+
+template <typename T>
+struct List {
+ size_t size;
+ T* items;
+
+ inline T* begin() const { return items; }
+ inline T* end() const { return items + size; }
+
+ inline List<T>& init(size_t size) {
+ this->size = size;
+ items = allocate<T>(size);
+ return *this;
+ }
+};
+
+// =======================================================================================
+
+struct SingleUseObjects {
+ class ObjectSizeCounter {
+ public:
+ ObjectSizeCounter(uint64_t iters): counter(0) {}
+
+ void add(uint64_t wordCount) {
+ counter += wordCount;
+ }
+
+ uint64_t get() { return counter; }
+
+ private:
+ uint64_t counter;
+ };
+};
+
+struct ReusableObjects {
+ class ObjectSizeCounter {
+ public:
+ ObjectSizeCounter(uint64_t iters): iters(iters), maxSize(0) {}
+
+ void add(size_t wordCount) {
+ maxSize = std::max(wordCount, maxSize);
+ }
+
+ uint64_t get() { return iters * maxSize; }
+
+ private:
+ uint64_t iters;
+ size_t maxSize;
+ };
+};
+
+// =======================================================================================
+
+template <typename TestCase, typename ReuseStrategy, typename Compression>
+struct BenchmarkMethods {
+ static uint64_t syncClient(int inputFd, int outputFd, uint64_t iters) {
+ fprintf(stderr, "Null benchmark doesn't do I/O.\n");
+ exit(1);
+ }
+
+ static uint64_t asyncClientSender(
+ int outputFd, ProducerConsumerQueue<typename TestCase::Expectation>* expectations,
+ uint64_t iters) {
+ fprintf(stderr, "Null benchmark doesn't do I/O.\n");
+ exit(1);
+ }
+
+ static void asyncClientReceiver(
+ int inputFd, ProducerConsumerQueue<typename TestCase::Expectation>* expectations,
+ uint64_t iters) {
+ fprintf(stderr, "Null benchmark doesn't do I/O.\n");
+ exit(1);
+ }
+
+ static uint64_t asyncClient(int inputFd, int outputFd, uint64_t iters) {
+ fprintf(stderr, "Null benchmark doesn't do I/O.\n");
+ exit(1);
+ }
+
+ static uint64_t server(int inputFd, int outputFd, uint64_t iters) {
+ fprintf(stderr, "Null benchmark doesn't do I/O.\n");
+ exit(1);
+ }
+
+ static uint64_t passByObject(uint64_t iters, bool countObjectSize) {
+ typename ReuseStrategy::ObjectSizeCounter sizeCounter(iters);
+
+ for (; iters > 0; --iters) {
+ arenaPos = arena;
+
+ typename TestCase::Request request;
+ typename TestCase::Expectation expected = TestCase::setupRequest(&request);
+
+ typename TestCase::Response response;
+ TestCase::handleRequest(request, &response);
+ if (!TestCase::checkResponse(response, expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+
+ sizeCounter.add((arenaPos - arena) * sizeof(arena[0]));
+ }
+
+ return sizeCounter.get();
+ }
+
+ static uint64_t passByBytes(uint64_t iters) {
+ fprintf(stderr, "Null benchmark doesn't do I/O.\n");
+ exit(1);
+ }
+};
+
+struct BenchmarkTypes {
+ typedef void Uncompressed;
+ typedef void Packed;
+#if HAVE_SNAPPY
+ typedef void SnappyCompressed;
+#endif // HAVE_SNAPPY
+
+ typedef ReusableObjects ReusableResources;
+ typedef SingleUseObjects SingleUseResources;
+
+ template <typename TestCase, typename ReuseStrategy, typename Compression>
+ struct BenchmarkMethods: public null::BenchmarkMethods<TestCase, ReuseStrategy, Compression> {};
+};
+
+} // namespace null
+} // namespace benchmark
+} // namespace capnp
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/protobuf-common.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/protobuf-common.h
new file mode 100644
index 0000000..c4ea244
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/benchmark/protobuf-common.h
@@ -0,0 +1,359 @@
+// 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.
+
+#include "common.h"
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <thread>
+#if HAVE_SNAPPY
+#include <snappy/snappy.h>
+#include <snappy/snappy-sinksource.h>
+#endif // HAVE_SNAPPY
+
+namespace capnp {
+namespace benchmark {
+namespace protobuf {
+
+// =======================================================================================
+
+struct SingleUseMessages {
+ template <typename MessageType>
+ struct Message {
+ struct Reusable {};
+ struct SingleUse: public MessageType {
+ inline SingleUse(Reusable&) {}
+ };
+ };
+
+ struct ReusableString {};
+ struct SingleUseString: std::string {
+ inline SingleUseString(ReusableString&) {}
+ };
+
+ template <typename MessageType>
+ static inline void doneWith(MessageType& message) {
+ // Don't clear -- single-use.
+ }
+};
+
+struct ReusableMessages {
+ template <typename MessageType>
+ struct Message {
+ struct Reusable: public MessageType {};
+ typedef MessageType& SingleUse;
+ };
+
+ typedef std::string ReusableString;
+ typedef std::string& SingleUseString;
+
+ template <typename MessageType>
+ static inline void doneWith(MessageType& message) {
+ message.Clear();
+ }
+};
+
+// =======================================================================================
+// The protobuf Java library defines a format for writing multiple protobufs to a stream, in which
+// each message is prefixed by a varint size. This was never added to the C++ library. It's easy
+// to do naively, but tricky to implement without accidentally losing various optimizations. These
+// two functions should be optimal.
+
+struct Uncompressed {
+ typedef google::protobuf::io::FileInputStream InputStream;
+ typedef google::protobuf::io::FileOutputStream OutputStream;
+
+ static uint64_t write(const google::protobuf::MessageLite& message,
+ google::protobuf::io::FileOutputStream* rawOutput) {
+ google::protobuf::io::CodedOutputStream output(rawOutput);
+ const int size = message.ByteSize();
+ output.WriteVarint32(size);
+ uint8_t* buffer = output.GetDirectBufferForNBytesAndAdvance(size);
+ if (buffer != NULL) {
+ message.SerializeWithCachedSizesToArray(buffer);
+ } else {
+ message.SerializeWithCachedSizes(&output);
+ if (output.HadError()) {
+ throw OsException(rawOutput->GetErrno());
+ }
+ }
+
+ return size;
+ }
+
+ static void read(google::protobuf::io::ZeroCopyInputStream* rawInput,
+ google::protobuf::MessageLite* message) {
+ google::protobuf::io::CodedInputStream input(rawInput);
+ uint32_t size;
+ GOOGLE_CHECK(input.ReadVarint32(&size));
+
+ auto limit = input.PushLimit(size);
+
+ GOOGLE_CHECK(message->MergePartialFromCodedStream(&input) &&
+ input.ConsumedEntireMessage());
+
+ input.PopLimit(limit);
+ }
+
+ static void flush(google::protobuf::io::FileOutputStream* output) {
+ if (!output->Flush()) throw OsException(output->GetErrno());
+ }
+};
+
+// =======================================================================================
+// The Snappy interface is really obnoxious. I gave up here and am just reading/writing flat
+// arrays in some static scratch space. This probably gives protobufs an edge that it doesn't
+// deserve.
+
+#if HAVE_SNAPPY
+
+static char scratch[1 << 20];
+static char scratch2[1 << 20];
+
+struct SnappyCompressed {
+ typedef int InputStream;
+ typedef int OutputStream;
+
+ static uint64_t write(const google::protobuf::MessageLite& message, int* output) {
+ size_t size = message.ByteSize();
+ GOOGLE_CHECK_LE(size, sizeof(scratch));
+
+ message.SerializeWithCachedSizesToArray(reinterpret_cast<uint8_t*>(scratch));
+
+ size_t compressedSize = 0;
+ snappy::RawCompress(scratch, size, scratch2 + sizeof(uint32_t), &compressedSize);
+ uint32_t tag = compressedSize;
+ memcpy(scratch2, &tag, sizeof(tag));
+
+ writeAll(*output, scratch2, compressedSize + sizeof(tag));
+ return compressedSize + sizeof(tag);
+ }
+
+ static void read(int* input, google::protobuf::MessageLite* message) {
+ uint32_t size;
+ readAll(*input, &size, sizeof(size));
+ readAll(*input, scratch, size);
+
+ size_t uncompressedSize;
+ GOOGLE_CHECK(snappy::GetUncompressedLength(scratch, size, &uncompressedSize));
+ GOOGLE_CHECK(snappy::RawUncompress(scratch, size, scratch2));
+
+ GOOGLE_CHECK(message->ParsePartialFromArray(scratch2, uncompressedSize));
+ }
+
+ static void flush(OutputStream*) {}
+};
+
+#endif // HAVE_SNAPPY
+
+// =======================================================================================
+
+#define REUSABLE(type) \
+ typename ReuseStrategy::template Message<typename TestCase::type>::Reusable
+#define SINGLE_USE(type) \
+ typename ReuseStrategy::template Message<typename TestCase::type>::SingleUse
+
+template <typename TestCase, typename ReuseStrategy, typename Compression>
+struct BenchmarkMethods {
+ static uint64_t syncClient(int inputFd, int outputFd, uint64_t iters) {
+ uint64_t throughput = 0;
+
+ typename Compression::OutputStream output(outputFd);
+ typename Compression::InputStream input(inputFd);
+
+ REUSABLE(Request) reusableRequest;
+ REUSABLE(Response) reusableResponse;
+
+ for (; iters > 0; --iters) {
+ SINGLE_USE(Request) request(reusableRequest);
+ typename TestCase::Expectation expected = TestCase::setupRequest(&request);
+ throughput += Compression::write(request, &output);
+ Compression::flush(&output);
+ ReuseStrategy::doneWith(request);
+
+ SINGLE_USE(Response) response(reusableResponse);
+ Compression::read(&input, &response);
+ if (!TestCase::checkResponse(response, expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+ ReuseStrategy::doneWith(response);
+ }
+
+ return throughput;
+ }
+
+ static uint64_t asyncClientSender(
+ int outputFd, ProducerConsumerQueue<typename TestCase::Expectation>* expectations,
+ uint64_t iters) {
+ uint64_t throughput = 0;
+
+ typename Compression::OutputStream output(outputFd);
+ REUSABLE(Request) reusableRequest;
+
+ for (; iters > 0; --iters) {
+ SINGLE_USE(Request) request(reusableRequest);
+ expectations->post(TestCase::setupRequest(&request));
+ throughput += Compression::write(request, &output);
+ Compression::flush(&output);
+ ReuseStrategy::doneWith(request);
+ }
+
+ return throughput;
+ }
+
+ static void asyncClientReceiver(
+ int inputFd, ProducerConsumerQueue<typename TestCase::Expectation>* expectations,
+ uint64_t iters) {
+ typename Compression::InputStream input(inputFd);
+ REUSABLE(Response) reusableResponse;
+
+ for (; iters > 0; --iters) {
+ typename TestCase::Expectation expected = expectations->next();
+ SINGLE_USE(Response) response(reusableResponse);
+ Compression::read(&input, &response);
+ if (!TestCase::checkResponse(response, expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+ ReuseStrategy::doneWith(response);
+ }
+ }
+
+ static uint64_t asyncClient(int inputFd, int outputFd, uint64_t iters) {
+ ProducerConsumerQueue<typename TestCase::Expectation> expectations;
+ std::thread receiverThread(asyncClientReceiver, inputFd, &expectations, iters);
+ uint64_t throughput = asyncClientSender(outputFd, &expectations, iters);
+ receiverThread.join();
+
+ return throughput;
+ }
+
+ static uint64_t server(int inputFd, int outputFd, uint64_t iters) {
+ uint64_t throughput = 0;
+
+ typename Compression::OutputStream output(outputFd);
+ typename Compression::InputStream input(inputFd);
+
+ REUSABLE(Request) reusableRequest;
+ REUSABLE(Response) reusableResponse;
+
+ for (; iters > 0; --iters) {
+ SINGLE_USE(Request) request(reusableRequest);
+ Compression::read(&input, &request);
+
+ SINGLE_USE(Response) response(reusableResponse);
+ TestCase::handleRequest(request, &response);
+ ReuseStrategy::doneWith(request);
+
+ throughput += Compression::write(response, &output);
+ Compression::flush(&output);
+ ReuseStrategy::doneWith(response);
+ }
+
+ return throughput;
+ }
+
+ static uint64_t passByObject(uint64_t iters, bool countObjectSize) {
+ uint64_t throughput = 0;
+
+ REUSABLE(Request) reusableRequest;
+ REUSABLE(Response) reusableResponse;
+
+ for (; iters > 0; --iters) {
+ SINGLE_USE(Request) request(reusableRequest);
+ typename TestCase::Expectation expected = TestCase::setupRequest(&request);
+
+ SINGLE_USE(Response) response(reusableResponse);
+ TestCase::handleRequest(request, &response);
+ ReuseStrategy::doneWith(request);
+ if (!TestCase::checkResponse(response, expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+ ReuseStrategy::doneWith(response);
+
+ if (countObjectSize) {
+ throughput += request.SpaceUsed();
+ throughput += response.SpaceUsed();
+ }
+ }
+
+ return throughput;
+ }
+
+ static uint64_t passByBytes(uint64_t iters) {
+ uint64_t throughput = 0;
+
+ REUSABLE(Request) reusableClientRequest;
+ REUSABLE(Request) reusableServerRequest;
+ REUSABLE(Response) reusableServerResponse;
+ REUSABLE(Response) reusableClientResponse;
+ typename ReuseStrategy::ReusableString reusableRequestString, reusableResponseString;
+
+ for (; iters > 0; --iters) {
+ SINGLE_USE(Request) clientRequest(reusableClientRequest);
+ typename TestCase::Expectation expected = TestCase::setupRequest(&clientRequest);
+
+ typename ReuseStrategy::SingleUseString requestString(reusableRequestString);
+ clientRequest.SerializePartialToString(&requestString);
+ throughput += requestString.size();
+ ReuseStrategy::doneWith(clientRequest);
+
+ SINGLE_USE(Request) serverRequest(reusableServerRequest);
+ serverRequest.ParsePartialFromString(requestString);
+
+ SINGLE_USE(Response) serverResponse(reusableServerResponse);
+ TestCase::handleRequest(serverRequest, &serverResponse);
+ ReuseStrategy::doneWith(serverRequest);
+
+ typename ReuseStrategy::SingleUseString responseString(reusableResponseString);
+ serverResponse.SerializePartialToString(&responseString);
+ throughput += responseString.size();
+ ReuseStrategy::doneWith(serverResponse);
+
+ SINGLE_USE(Response) clientResponse(reusableClientResponse);
+ clientResponse.ParsePartialFromString(responseString);
+
+ if (!TestCase::checkResponse(clientResponse, expected)) {
+ throw std::logic_error("Incorrect response.");
+ }
+ ReuseStrategy::doneWith(clientResponse);
+ }
+
+ return throughput;
+ }
+};
+
+struct BenchmarkTypes {
+ typedef protobuf::Uncompressed Uncompressed;
+ typedef protobuf::Uncompressed Packed;
+#if HAVE_SNAPPY
+ typedef protobuf::SnappyCompressed SnappyCompressed;
+#endif // HAVE_SNAPPY
+
+ typedef protobuf::ReusableMessages ReusableResources;
+ typedef protobuf::SingleUseMessages SingleUseResources;
+
+ template <typename TestCase, typename ReuseStrategy, typename Compression>
+ struct BenchmarkMethods
+ : public protobuf::BenchmarkMethods<TestCase, ReuseStrategy, Compression> {};
+};
+
+} // namespace protobuf
+} // namespace benchmark
+} // namespace capnp
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/arena.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/arena.h
new file mode 100644
index 0000000..e3cacf3
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/arena.h
@@ -0,0 +1,496 @@
+// 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.
+
+#ifndef CAPNP_ARENA_H_
+#define CAPNP_ARENA_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#ifndef CAPNP_PRIVATE
+#error "This header is only meant to be included by Cap'n Proto's own source code."
+#endif
+
+#include <kj/common.h>
+#include <kj/mutex.h>
+#include <kj/exception.h>
+#include <kj/vector.h>
+#include <kj/units.h>
+#include "common.h"
+#include "message.h"
+#include "layout.h"
+#include <unordered_map>
+
+#if !CAPNP_LITE
+#include "capability.h"
+#endif // !CAPNP_LITE
+
+namespace capnp {
+
+#if !CAPNP_LITE
+class ClientHook;
+#endif // !CAPNP_LITE
+
+namespace _ { // private
+
+class SegmentReader;
+class SegmentBuilder;
+class Arena;
+class BuilderArena;
+class ReadLimiter;
+
+class Segment;
+typedef kj::Id<uint32_t, Segment> SegmentId;
+
+class ReadLimiter {
+ // Used to keep track of how much data has been processed from a message, and cut off further
+ // processing if and when a particular limit is reached. This is primarily intended to guard
+ // against maliciously-crafted messages which contain cycles or overlapping structures. Cycles
+ // and overlapping are not permitted by the Cap'n Proto format because in many cases they could
+ // be used to craft a deceptively small message which could consume excessive server resources to
+ // process, perhaps even sending it into an infinite loop. Actually detecting overlaps would be
+ // time-consuming, so instead we just keep track of how many words worth of data structures the
+ // receiver has actually dereferenced and error out if this gets too high.
+ //
+ // This counting takes place as you call getters (for non-primitive values) on the message
+ // readers. If you call the same getter twice, the data it returns may be double-counted. This
+ // should not be a big deal in most cases -- just set the read limit high enough that it will
+ // only trigger in unreasonable cases.
+ //
+ // This class is "safe" to use from multiple threads for its intended use case. Threads may
+ // overwrite each others' changes to the counter, but this is OK because it only means that the
+ // limit is enforced a bit less strictly -- it will still kick in eventually.
+
+public:
+ inline explicit ReadLimiter(); // No limit.
+ inline explicit ReadLimiter(WordCount64 limit); // Limit to the given number of words.
+
+ inline void reset(WordCount64 limit);
+
+ KJ_ALWAYS_INLINE(bool canRead(WordCount64 amount, Arena* arena));
+
+ void unread(WordCount64 amount);
+ // Adds back some words to the limit. Useful when the caller knows they are double-reading
+ // some data.
+
+private:
+ volatile uint64_t limit;
+ // Current limit, decremented each time catRead() is called. Volatile because multiple threads
+ // could be trying to modify it at once. (This is not real thread-safety, but good enough for
+ // the purpose of this class. See class comment.)
+
+ KJ_DISALLOW_COPY(ReadLimiter);
+};
+
+#if !CAPNP_LITE
+class BrokenCapFactory {
+ // Callback for constructing broken caps. We use this so that we can avoid arena.c++ having a
+ // link-time dependency on capability code that lives in libcapnp-rpc.
+
+public:
+ virtual kj::Own<ClientHook> newBrokenCap(kj::StringPtr description) = 0;
+ virtual kj::Own<ClientHook> newNullCap() = 0;
+};
+#endif // !CAPNP_LITE
+
+class SegmentReader {
+public:
+ inline SegmentReader(Arena* arena, SegmentId id, const word* ptr, SegmentWordCount size,
+ ReadLimiter* readLimiter);
+
+ KJ_ALWAYS_INLINE(const word* checkOffset(const word* from, ptrdiff_t offset));
+ // Adds the given offset to the given pointer, checks that it is still within the bounds of the
+ // segment, then returns it. Note that the "end" pointer of the segment (which technically points
+ // to the word after the last in the segment) is considered in-bounds for this purpose, so you
+ // can't necessarily dereference it. You must call checkObject() next to check that the object
+ // you want to read is entirely in-bounds.
+ //
+ // If `from + offset` is out-of-range, this returns a pointer to the end of the segment. Thus,
+ // any non-zero-sized object will fail `checkObject()`. We do this instead of throwing to save
+ // some code footprint.
+
+ KJ_ALWAYS_INLINE(bool checkObject(const word* start, WordCountN<31> size));
+ // Assuming that `start` is in-bounds for this segment (probably checked using `checkOffset()`),
+ // check that `start + size` is also in-bounds, and hence the whole area in-between is valid.
+
+ KJ_ALWAYS_INLINE(bool amplifiedRead(WordCount virtualAmount));
+ // Indicates that the reader should pretend that `virtualAmount` additional data was read even
+ // though no actual pointer was traversed. This is used e.g. when reading a struct list pointer
+ // where the element sizes are zero -- the sender could set the list size arbitrarily high and
+ // cause the receiver to iterate over this list even though the message itself is small, so we
+ // need to defend against DoS attacks based on this.
+
+ inline Arena* getArena();
+ inline SegmentId getSegmentId();
+
+ inline const word* getStartPtr();
+ inline SegmentWordCount getOffsetTo(const word* ptr);
+ inline SegmentWordCount getSize();
+
+ inline kj::ArrayPtr<const word> getArray();
+
+ inline void unread(WordCount64 amount);
+ // Add back some words to the ReadLimiter.
+
+private:
+ Arena* arena;
+ SegmentId id;
+ kj::ArrayPtr<const word> ptr; // size guaranteed to fit in SEGMENT_WORD_COUNT_BITS bits
+ ReadLimiter* readLimiter;
+
+ KJ_DISALLOW_COPY(SegmentReader);
+
+ friend class SegmentBuilder;
+
+ static void abortCheckObjectFault();
+ // Called in debug mode in cases that would segfault in opt mode. (Should be impossible!)
+};
+
+class SegmentBuilder: public SegmentReader {
+public:
+ inline SegmentBuilder(BuilderArena* arena, SegmentId id, word* ptr, SegmentWordCount size,
+ ReadLimiter* readLimiter, SegmentWordCount wordsUsed = ZERO * WORDS);
+ inline SegmentBuilder(BuilderArena* arena, SegmentId id, const word* ptr, SegmentWordCount size,
+ ReadLimiter* readLimiter);
+ inline SegmentBuilder(BuilderArena* arena, SegmentId id, decltype(nullptr),
+ ReadLimiter* readLimiter);
+
+ KJ_ALWAYS_INLINE(word* allocate(SegmentWordCount amount));
+
+ KJ_ALWAYS_INLINE(void checkWritable());
+ // Throw an exception if the segment is read-only (meaning it is a reference to external data).
+
+ KJ_ALWAYS_INLINE(word* getPtrUnchecked(SegmentWordCount offset));
+ // Get a writable pointer into the segment. Throws an exception if the segment is read-only (i.e.
+ // a reference to external immutable data).
+
+ inline BuilderArena* getArena();
+
+ inline kj::ArrayPtr<const word> currentlyAllocated();
+
+ inline void reset();
+
+ inline bool isWritable() { return !readOnly; }
+
+ inline void tryTruncate(word* from, word* to);
+ // If `from` points just past the current end of the segment, then move the end back to `to`.
+ // Otherwise, do nothing.
+
+ inline bool tryExtend(word* from, word* to);
+ // If `from` points just past the current end of the segment, and `to` is within the segment
+ // boundaries, then move the end up to `to` and return true. Otherwise, do nothing and return
+ // false.
+
+private:
+ word* pos;
+ // Pointer to a pointer to the current end point of the segment, i.e. the location where the
+ // next object should be allocated.
+
+ bool readOnly;
+
+ void throwNotWritable();
+
+ KJ_DISALLOW_COPY(SegmentBuilder);
+};
+
+class Arena {
+public:
+ virtual ~Arena() noexcept(false);
+
+ virtual SegmentReader* tryGetSegment(SegmentId id) = 0;
+ // Gets the segment with the given ID, or return nullptr if no such segment exists.
+
+ virtual void reportReadLimitReached() = 0;
+ // Called to report that the read limit has been reached. See ReadLimiter, below. This invokes
+ // the VALIDATE_INPUT() macro which may throw an exception; if it returns normally, the caller
+ // will need to continue with default values.
+};
+
+class ReaderArena final: public Arena {
+public:
+ explicit ReaderArena(MessageReader* message);
+ ~ReaderArena() noexcept(false);
+ KJ_DISALLOW_COPY(ReaderArena);
+
+ // implements Arena ------------------------------------------------
+ SegmentReader* tryGetSegment(SegmentId id) override;
+ void reportReadLimitReached() override;
+
+private:
+ MessageReader* message;
+ ReadLimiter readLimiter;
+
+ // Optimize for single-segment messages so that small messages are handled quickly.
+ SegmentReader segment0;
+
+ typedef std::unordered_map<uint, kj::Own<SegmentReader>> SegmentMap;
+ kj::MutexGuarded<kj::Maybe<kj::Own<SegmentMap>>> moreSegments;
+ // We need to mutex-guard the segment map because we lazily initialize segments when they are
+ // first requested, but a Reader is allowed to be used concurrently in multiple threads. Luckily
+ // this only applies to large messages.
+ //
+ // TODO(perf): Thread-local thing instead? Some kind of lockless map? Or do sharing of data
+ // in a different way, where you have to construct a new MessageReader in each thread (but
+ // possibly backed by the same data)?
+
+ ReaderArena(MessageReader* message, kj::ArrayPtr<const word> firstSegment);
+ ReaderArena(MessageReader* message, const word* firstSegment, SegmentWordCount firstSegmentSize);
+};
+
+class BuilderArena final: public Arena {
+ // A BuilderArena that does not allow the injection of capabilities.
+
+public:
+ explicit BuilderArena(MessageBuilder* message);
+ BuilderArena(MessageBuilder* message, kj::ArrayPtr<MessageBuilder::SegmentInit> segments);
+ ~BuilderArena() noexcept(false);
+ KJ_DISALLOW_COPY(BuilderArena);
+
+ inline SegmentBuilder* getRootSegment() { return &segment0; }
+
+ kj::ArrayPtr<const kj::ArrayPtr<const word>> getSegmentsForOutput();
+ // Get an array of all the segments, suitable for writing out. This only returns the allocated
+ // portion of each segment, whereas tryGetSegment() returns something that includes
+ // not-yet-allocated space.
+
+ inline CapTableBuilder* getLocalCapTable() {
+ // Return a CapTableBuilder that merely implements local loopback. That is, you can set
+ // capabilities, then read the same capabilities back, but there is no intent ever to transmit
+ // these capabilities. A MessageBuilder that isn't imbued with some other CapTable uses this
+ // by default.
+ //
+ // TODO(cleanup): It's sort of a hack that this exists. In theory, perhaps, unimbued
+ // MessageBuilders should throw exceptions on any attempt to access capability fields, like
+ // unimbued MessageReaders do. However, lots of code exists which uses MallocMessageBuilder
+ // as a temporary holder for data to be copied in and out (without being serialized), and it
+ // is expected that such data can include capabilities, which is admittedly reasonable.
+ // Therefore, all MessageBuilders must have a cap table by default. Arguably we should
+ // deprecate this usage and instead define a new helper type for this exact purpose.
+
+ return &localCapTable;
+ }
+
+ SegmentBuilder* getSegment(SegmentId id);
+ // Get the segment with the given id. Crashes or throws an exception if no such segment exists.
+
+ struct AllocateResult {
+ SegmentBuilder* segment;
+ word* words;
+ };
+
+ AllocateResult allocate(SegmentWordCount amount);
+ // Find a segment with at least the given amount of space available and allocate the space.
+ // Note that allocating directly from a particular segment is much faster, but allocating from
+ // the arena is guaranteed to succeed. Therefore callers should try to allocate from a specific
+ // segment first if there is one, then fall back to the arena.
+
+ SegmentBuilder* addExternalSegment(kj::ArrayPtr<const word> content);
+ // Add a new segment to the arena which points to some existing memory region. The segment is
+ // assumed to be completley full; the arena will never allocate from it. In fact, the segment
+ // is considered read-only. Any attempt to get a Builder pointing into this segment will throw
+ // an exception. Readers are allowed, however.
+ //
+ // This can be used to inject some external data into a message without a copy, e.g. embedding a
+ // large mmap'd file into a message as `Data` without forcing that data to actually be read in
+ // from disk (until the message itself is written out). `Orphanage` provides the public API for
+ // this feature.
+
+ // implements Arena ------------------------------------------------
+ SegmentReader* tryGetSegment(SegmentId id) override;
+ void reportReadLimitReached() override;
+
+private:
+ MessageBuilder* message;
+ ReadLimiter dummyLimiter;
+
+ class LocalCapTable: public CapTableBuilder {
+#if !CAPNP_LITE
+ public:
+ kj::Maybe<kj::Own<ClientHook>> extractCap(uint index) override;
+ uint injectCap(kj::Own<ClientHook>&& cap) override;
+ void dropCap(uint index) override;
+
+ private:
+ kj::Vector<kj::Maybe<kj::Own<ClientHook>>> capTable;
+#endif // ! CAPNP_LITE
+ };
+
+ LocalCapTable localCapTable;
+
+ SegmentBuilder segment0;
+ kj::ArrayPtr<const word> segment0ForOutput;
+
+ struct MultiSegmentState {
+ kj::Vector<kj::Own<SegmentBuilder>> builders;
+ kj::Vector<kj::ArrayPtr<const word>> forOutput;
+ };
+ kj::Maybe<kj::Own<MultiSegmentState>> moreSegments;
+
+ SegmentBuilder* segmentWithSpace = nullptr;
+ // When allocating, look for space in this segment first before resorting to allocating a new
+ // segment. This is not necessarily the last segment because addExternalSegment() may add a
+ // segment that is already-full, in which case we don't update this pointer.
+
+ template <typename T> // Can be `word` or `const word`.
+ SegmentBuilder* addSegmentInternal(kj::ArrayPtr<T> content);
+};
+
+// =======================================================================================
+
+inline ReadLimiter::ReadLimiter()
+ : limit(kj::maxValue) {}
+
+inline ReadLimiter::ReadLimiter(WordCount64 limit): limit(unbound(limit / WORDS)) {}
+
+inline void ReadLimiter::reset(WordCount64 limit) { this->limit = unbound(limit / WORDS); }
+
+inline bool ReadLimiter::canRead(WordCount64 amount, Arena* arena) {
+ // Be careful not to store an underflowed value into `limit`, even if multiple threads are
+ // decrementing it.
+ uint64_t current = limit;
+ if (KJ_UNLIKELY(unbound(amount / WORDS) > current)) {
+ arena->reportReadLimitReached();
+ return false;
+ } else {
+ limit = current - unbound(amount / WORDS);
+ return true;
+ }
+}
+
+// -------------------------------------------------------------------
+
+inline SegmentReader::SegmentReader(Arena* arena, SegmentId id, const word* ptr,
+ SegmentWordCount size, ReadLimiter* readLimiter)
+ : arena(arena), id(id), ptr(kj::arrayPtr(ptr, unbound(size / WORDS))),
+ readLimiter(readLimiter) {}
+
+inline const word* SegmentReader::checkOffset(const word* from, ptrdiff_t offset) {
+ ptrdiff_t min = ptr.begin() - from;
+ ptrdiff_t max = ptr.end() - from;
+ if (offset >= min && offset <= max) {
+ return from + offset;
+ } else {
+ return ptr.end();
+ }
+}
+
+inline bool SegmentReader::checkObject(const word* start, WordCountN<31> size) {
+ auto startOffset = intervalLength(ptr.begin(), start, MAX_SEGMENT_WORDS);
+#ifdef KJ_DEBUG
+ if (startOffset > bounded(ptr.size()) * WORDS) {
+ abortCheckObjectFault();
+ }
+#endif
+ return startOffset + size <= bounded(ptr.size()) * WORDS &&
+ readLimiter->canRead(size, arena);
+}
+
+inline bool SegmentReader::amplifiedRead(WordCount virtualAmount) {
+ return readLimiter->canRead(virtualAmount, arena);
+}
+
+inline Arena* SegmentReader::getArena() { return arena; }
+inline SegmentId SegmentReader::getSegmentId() { return id; }
+inline const word* SegmentReader::getStartPtr() { return ptr.begin(); }
+inline SegmentWordCount SegmentReader::getOffsetTo(const word* ptr) {
+ KJ_IREQUIRE(this->ptr.begin() <= ptr && ptr <= this->ptr.end());
+ return intervalLength(this->ptr.begin(), ptr, MAX_SEGMENT_WORDS);
+}
+inline SegmentWordCount SegmentReader::getSize() {
+ return assumeBits<SEGMENT_WORD_COUNT_BITS>(ptr.size()) * WORDS;
+}
+inline kj::ArrayPtr<const word> SegmentReader::getArray() { return ptr; }
+inline void SegmentReader::unread(WordCount64 amount) { readLimiter->unread(amount); }
+
+// -------------------------------------------------------------------
+
+inline SegmentBuilder::SegmentBuilder(
+ BuilderArena* arena, SegmentId id, word* ptr, SegmentWordCount size,
+ ReadLimiter* readLimiter, SegmentWordCount wordsUsed)
+ : SegmentReader(arena, id, ptr, size, readLimiter),
+ pos(ptr + wordsUsed), readOnly(false) {}
+inline SegmentBuilder::SegmentBuilder(
+ BuilderArena* arena, SegmentId id, const word* ptr, SegmentWordCount size,
+ ReadLimiter* readLimiter)
+ : SegmentReader(arena, id, ptr, size, readLimiter),
+ // const_cast is safe here because the member won't ever be dereferenced because it appears
+ // to point to the end of the segment anyway.
+ pos(const_cast<word*>(ptr + size)), readOnly(true) {}
+inline SegmentBuilder::SegmentBuilder(BuilderArena* arena, SegmentId id, decltype(nullptr),
+ ReadLimiter* readLimiter)
+ : SegmentReader(arena, id, nullptr, ZERO * WORDS, readLimiter),
+ pos(nullptr), readOnly(false) {}
+
+inline word* SegmentBuilder::allocate(SegmentWordCount amount) {
+ if (intervalLength(pos, ptr.end(), MAX_SEGMENT_WORDS) < amount) {
+ // Not enough space in the segment for this allocation.
+ return nullptr;
+ } else {
+ // Success.
+ word* result = pos;
+ pos = pos + amount;
+ return result;
+ }
+}
+
+inline void SegmentBuilder::checkWritable() {
+ if (KJ_UNLIKELY(readOnly)) throwNotWritable();
+}
+
+inline word* SegmentBuilder::getPtrUnchecked(SegmentWordCount offset) {
+ return const_cast<word*>(ptr.begin() + offset);
+}
+
+inline BuilderArena* SegmentBuilder::getArena() {
+ // Down-cast safe because SegmentBuilder's constructor always initializes its SegmentReader base
+ // class with an Arena pointer that actually points to a BuilderArena.
+ return static_cast<BuilderArena*>(arena);
+}
+
+inline kj::ArrayPtr<const word> SegmentBuilder::currentlyAllocated() {
+ return kj::arrayPtr(ptr.begin(), pos - ptr.begin());
+}
+
+inline void SegmentBuilder::reset() {
+ word* start = getPtrUnchecked(ZERO * WORDS);
+ memset(start, 0, (pos - start) * sizeof(word));
+ pos = start;
+}
+
+inline void SegmentBuilder::tryTruncate(word* from, word* to) {
+ if (pos == from) pos = to;
+}
+
+inline bool SegmentBuilder::tryExtend(word* from, word* to) {
+ // Careful about overflow.
+ if (pos == from && to <= ptr.end() && to >= from) {
+ pos = to;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+} // namespace _ (private)
+} // namespace capnp
+
+#endif // CAPNP_ARENA_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/compiler.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/compiler.h
new file mode 100644
index 0000000..0362c30
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/compiler.h
@@ -0,0 +1,204 @@
+// 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.
+
+#ifndef CAPNP_COMPILER_COMPILER_H_
+#define CAPNP_COMPILER_COMPILER_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include <capnp/compiler/grammar.capnp.h>
+#include <capnp/schema.capnp.h>
+#include <capnp/schema-loader.h>
+#include "error-reporter.h"
+
+namespace capnp {
+namespace compiler {
+
+class Module: public ErrorReporter {
+public:
+ virtual kj::StringPtr getSourceName() = 0;
+ // The name of the module file relative to the source tree. Used to decide where to output
+ // generated code and to form the `displayName` in the schema.
+
+ virtual Orphan<ParsedFile> loadContent(Orphanage orphanage) = 0;
+ // Loads the module content, using the given orphanage to allocate objects if necessary.
+
+ virtual kj::Maybe<Module&> importRelative(kj::StringPtr importPath) = 0;
+ // Find another module, relative to this one. Importing the same logical module twice should
+ // produce the exact same object, comparable by identity. These objects are owned by some
+ // outside pool that outlives the Compiler instance.
+
+ virtual kj::Maybe<kj::Array<const byte>> embedRelative(kj::StringPtr embedPath) = 0;
+ // Read and return the content of a file specified using `embed`.
+};
+
+class Compiler final: private SchemaLoader::LazyLoadCallback {
+ // Cross-links separate modules (schema files) and translates them into schema nodes.
+ //
+ // This class is thread-safe, hence all its methods are const.
+
+public:
+ enum AnnotationFlag {
+ COMPILE_ANNOTATIONS,
+ // Compile annotations normally.
+
+ DROP_ANNOTATIONS
+ // Do not compile any annotations, eagerly or lazily. All "annotations" fields in the schema
+ // will be left empty. This is useful to avoid parsing imports that are used only for
+ // annotations which you don't intend to use anyway.
+ //
+ // Unfortunately annotations cannot simply be compiled lazily because filling in the
+ // "annotations" field at the usage site requires knowing the annotation's type, which requires
+ // compiling the annotation, and the schema API has no particular way to detect when you
+ // try to access the "annotations" field in order to lazily compile the annotations at that
+ // point.
+ };
+
+ explicit Compiler(AnnotationFlag annotationFlag = COMPILE_ANNOTATIONS);
+ ~Compiler() noexcept(false);
+ KJ_DISALLOW_COPY(Compiler);
+
+ uint64_t add(Module& module) const;
+ // Add a module to the Compiler, returning the module's file ID. The ID can then be looked up in
+ // the `SchemaLoader` returned by `getLoader()`. However, the SchemaLoader may behave as if the
+ // schema node doesn't exist if any compilation errors occur (reported via the module's
+ // ErrorReporter). The module is parsed at the time `add()` is called, but not fully compiled --
+ // individual schema nodes are compiled lazily. If you want to force eager compilation,
+ // see `eagerlyCompile()`, below.
+
+ kj::Maybe<uint64_t> lookup(uint64_t parent, kj::StringPtr childName) const;
+ // Given the type ID of a schema node, find the ID of a node nested within it. Throws an
+ // exception if the parent ID is not recognized; returns null if the parent has no child of the
+ // given name. Neither the parent nor the child schema node is actually compiled.
+
+ kj::Maybe<schema::Node::SourceInfo::Reader> getSourceInfo(uint64_t id) const;
+ // Get the SourceInfo for the given type ID, if available.
+
+ Orphan<List<schema::CodeGeneratorRequest::RequestedFile::Import>>
+ getFileImportTable(Module& module, Orphanage orphanage) const;
+ // Build the import table for the CodeGeneratorRequest for the given module.
+
+ Orphan<List<schema::Node::SourceInfo>> getAllSourceInfo(Orphanage orphanage) const;
+ // Gets the SourceInfo structs for all nodes parsed by the compiler.
+
+ enum Eagerness: uint32_t {
+ // Flags specifying how eager to be about compilation. These are intended to be bitwise OR'd.
+ // Used with the method `eagerlyCompile()`.
+ //
+ // Schema declarations can be compiled upfront, or they can be compiled lazily as they are
+ // needed. Usually, the difference is not observable, but it is not a perfect abstraction.
+ // The difference has the following effects:
+ // * `getLoader().getAllLoaded()` only returns the schema nodes which have been compiled so
+ // far.
+ // * `getLoader().get()` (i.e. searching for a schema by ID) can only find schema nodes that
+ // have either been compiled already, or which are referenced by schema nodes which have been
+ // compiled already. This means that if the ID you pass in came from another schema node
+ // compiled with the same compiler, there should be no observable difference, but if you
+ // have an ID from elsewhere which you _a priori_ expect is defined in a particular schema
+ // file, you will need to compile that file eagerly before you look up the node by ID.
+ // * Errors are reported when they are encountered, so some errors will not be reported until
+ // the node is actually compiled.
+ // * If an imported file is not needed, it will never even be read from disk.
+ //
+ // The last point is the main reason why you might want to prefer lazy compilation: it allows
+ // you to use a schema file with missing imports, so long as those missing imports are not
+ // actually needed.
+ //
+ // For example, the flag combo:
+ // EAGER_NODE | EAGER_CHILDREN | EAGER_DEPENDENCIES | EAGER_DEPENDENCY_PARENTS
+ // will compile the entire given module, plus all direct dependencies of anything in that
+ // module, plus all lexical ancestors of those dependencies. This is what the Cap'n Proto
+ // compiler uses when building initial code generator requests.
+
+ ALL_RELATED_NODES = ~0u,
+ // Compile everything that is in any way related to the target node, including its entire
+ // containing file and everything transitively imported by it.
+
+ NODE = 1 << 0,
+ // Eagerly compile the requested node, but not necessarily any of its parents, children, or
+ // dependencies.
+
+ PARENTS = 1 << 1,
+ // Eagerly compile all lexical parents of the requested node. Only meaningful in conjuction
+ // with NODE.
+
+ CHILDREN = 1 << 2,
+ // Eagerly compile all of the node's lexically nested nodes. Only meaningful in conjuction
+ // with NODE.
+
+ DEPENDENCIES = NODE << 15,
+ // For all nodes compiled as a result of the above flags, also compile their direct
+ // dependencies. E.g. if Foo is a struct which contains a field of type Bar, and Foo is
+ // compiled, then also compile Bar. "Dependencies" are defined as field types, method
+ // parameter and return types, and annotation types. Nested types and outer types are not
+ // considered dependencies.
+
+ DEPENDENCY_PARENTS = PARENTS * DEPENDENCIES,
+ DEPENDENCY_CHILDREN = CHILDREN * DEPENDENCIES,
+ DEPENDENCY_DEPENDENCIES = DEPENDENCIES * DEPENDENCIES,
+ // Like PARENTS, CHILDREN, and DEPENDENCIES, but applies relative to dependency nodes rather
+ // than the original requested node. Note that DEPENDENCY_DEPENDENCIES causes all transitive
+ // dependencies of the requested node to be compiled.
+ //
+ // These flags are defined as multiples of the original flag and DEPENDENCIES so that we
+ // can form the flags to use when traversing a dependency by shifting bits.
+ };
+
+ void eagerlyCompile(uint64_t id, uint eagerness) const;
+ // Force eager compilation of schema nodes related to the given ID. `eagerness` specifies which
+ // related nodes should be compiled before returning. It is a bitwise OR of the possible values
+ // of the `Eagerness` enum.
+ //
+ // If this returns and no errors have been reported, then it is guaranteed that the compiled
+ // nodes can be found in the SchemaLoader returned by `getLoader()`.
+
+ const SchemaLoader& getLoader() const { return loader; }
+ SchemaLoader& getLoader() { return loader; }
+ // Get a SchemaLoader backed by this compiler. Schema nodes will be lazily constructed as you
+ // traverse them using this loader.
+
+ void clearWorkspace() const;
+ // The compiler builds a lot of temporary tables and data structures while it works. It's
+ // useful to keep these around if more work is expected (especially if you are using lazy
+ // compilation and plan to look up Schema nodes that haven't already been seen), but once
+ // the SchemaLoader has everything you need, you can call clearWorkspace() to free up the
+ // temporary space. Note that it's safe to call clearWorkspace() even if you do expect to
+ // compile more nodes in the future; it may simply lead to redundant work if the discarded
+ // structures are needed again.
+
+private:
+ class Impl;
+ kj::MutexGuarded<kj::Own<Impl>> impl;
+ SchemaLoader loader;
+
+ class CompiledModule;
+ class Node;
+ class Alias;
+
+ void load(const SchemaLoader& loader, uint64_t id) const override;
+};
+
+} // namespace compiler
+} // namespace capnp
+
+#endif // CAPNP_COMPILER_COMPILER_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/error-reporter.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/error-reporter.h
new file mode 100644
index 0000000..e4a04bf
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/error-reporter.h
@@ -0,0 +1,97 @@
+// 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.
+
+#ifndef ERROR_REPORTER_H_
+#define ERROR_REPORTER_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include "../common.h"
+#include <kj/string.h>
+#include <kj/exception.h>
+#include <kj/vector.h>
+
+namespace capnp {
+namespace compiler {
+
+class ErrorReporter {
+ // Callback for reporting errors within a particular file.
+
+public:
+ virtual void addError(uint32_t startByte, uint32_t endByte, kj::StringPtr message) = 0;
+ // Report an error at the given location in the input text. `startByte` and `endByte` indicate
+ // the span of text that is erroneous. They may be equal, in which case the parser was only
+ // able to identify where the error begins, not where it ends.
+
+ template <typename T>
+ inline void addErrorOn(T&& decl, kj::StringPtr message) {
+ // Works for any `T` that defines `getStartByte()` and `getEndByte()` methods, which many
+ // of the Cap'n Proto types defined in `grammar.capnp` do.
+
+ addError(decl.getStartByte(), decl.getEndByte(), message);
+ }
+
+ virtual bool hadErrors() = 0;
+ // Return true if any errors have been reported, globally. The main use case for this callback
+ // is to inhibit the reporting of errors which may have been caused by previous errors, or to
+ // allow the compiler to bail out entirely if it gets confused and thinks this could be because
+ // of previous errors.
+};
+
+class GlobalErrorReporter {
+ // Callback for reporting errors in any file.
+
+public:
+ struct SourcePos {
+ uint byte;
+ uint line;
+ uint column;
+ };
+
+ virtual void addError(kj::StringPtr file, SourcePos start, SourcePos end,
+ kj::StringPtr message) = 0;
+ // Report an error at the given location in the given file.
+
+ virtual bool hadErrors() = 0;
+ // Return true if any errors have been reported, globally. The main use case for this callback
+ // is to inhibit the reporting of errors which may have been caused by previous errors, or to
+ // allow the compiler to bail out entirely if it gets confused and thinks this could be because
+ // of previous errors.
+};
+
+class LineBreakTable {
+public:
+ LineBreakTable(kj::ArrayPtr<const char> content);
+
+ GlobalErrorReporter::SourcePos toSourcePos(uint32_t byteOffset) const;
+
+private:
+ kj::Vector<uint> lineBreaks;
+ // Byte offsets of the first byte in each source line. The first element is always zero.
+ // Initialized the first time the module is loaded.
+};
+
+} // namespace compiler
+} // namespace capnp
+
+#endif // ERROR_REPORTER_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/grammar.capnp.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/grammar.capnp.h
new file mode 100644
index 0000000..b89666b
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/grammar.capnp.h
@@ -0,0 +1,6837 @@
+// Generated by Cap'n Proto compiler, DO NOT EDIT
+// source: grammar.capnp
+
+#ifndef CAPNP_INCLUDED_c56be168dcbbc3c6_
+#define CAPNP_INCLUDED_c56be168dcbbc3c6_
+
+#include <capnp/generated-header-support.h>
+
+#if CAPNP_VERSION != 7000
+#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(e75816b56529d464);
+CAPNP_DECLARE_SCHEMA(991c7a3693d62cf2);
+CAPNP_DECLARE_SCHEMA(90f2a60678fd2367);
+CAPNP_DECLARE_SCHEMA(8e207d4dfe54d0de);
+CAPNP_DECLARE_SCHEMA(c90246b71adedbaa);
+CAPNP_DECLARE_SCHEMA(aee8397040b0df7a);
+CAPNP_DECLARE_SCHEMA(aa28e1400d793359);
+CAPNP_DECLARE_SCHEMA(96efe787c17e83bb);
+CAPNP_DECLARE_SCHEMA(d5e71144af1ce175);
+CAPNP_DECLARE_SCHEMA(d00489d473826290);
+CAPNP_DECLARE_SCHEMA(fb5aeed95cdf6af9);
+CAPNP_DECLARE_SCHEMA(94099c3f9eb32d6b);
+CAPNP_DECLARE_SCHEMA(b3f66e7a79d81bcd);
+CAPNP_DECLARE_SCHEMA(fffe08a9a697d2a5);
+CAPNP_DECLARE_SCHEMA(e5104515fd88ea47);
+CAPNP_DECLARE_SCHEMA(89f0c973c103ae96);
+CAPNP_DECLARE_SCHEMA(e93164a80bfe2ccf);
+CAPNP_DECLARE_SCHEMA(b348322a8dcf0d0c);
+CAPNP_DECLARE_SCHEMA(8f2622208fb358c8);
+CAPNP_DECLARE_SCHEMA(d0d1a21de617951f);
+CAPNP_DECLARE_SCHEMA(992a90eaf30235d3);
+CAPNP_DECLARE_SCHEMA(eb971847d617c0b9);
+CAPNP_DECLARE_SCHEMA(c6238c7d62d65173);
+CAPNP_DECLARE_SCHEMA(9cb9e86e3198037f);
+CAPNP_DECLARE_SCHEMA(84e4f3f5a807605c);
+
+} // namespace schemas
+} // namespace capnp
+
+namespace capnp {
+namespace compiler {
+
+struct LocatedText {
+ LocatedText() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(e75816b56529d464, 1, 1)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct LocatedInteger {
+ LocatedInteger() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(991c7a3693d62cf2, 2, 0)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct LocatedFloat {
+ LocatedFloat() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(90f2a60678fd2367, 2, 0)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Expression {
+ Expression() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ UNKNOWN,
+ POSITIVE_INT,
+ NEGATIVE_INT,
+ FLOAT,
+ STRING,
+ RELATIVE_NAME,
+ LIST,
+ TUPLE,
+ BINARY,
+ APPLICATION,
+ MEMBER,
+ ABSOLUTE_NAME,
+ IMPORT,
+ EMBED,
+ };
+ struct Param;
+ struct Application;
+ struct Member;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(8e207d4dfe54d0de, 3, 2)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Expression::Param {
+ Param() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ UNNAMED,
+ NAMED,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(c90246b71adedbaa, 1, 2)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Expression::Application {
+ Application() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(aee8397040b0df7a, 3, 2)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Expression::Member {
+ Member() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(aa28e1400d793359, 3, 2)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration {
+ Declaration() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ FILE,
+ USING,
+ CONST,
+ ENUM,
+ ENUMERANT,
+ STRUCT,
+ FIELD,
+ UNION,
+ GROUP,
+ INTERFACE,
+ METHOD,
+ ANNOTATION,
+ NAKED_ID,
+ NAKED_ANNOTATION,
+ BUILTIN_VOID,
+ BUILTIN_BOOL,
+ BUILTIN_INT8,
+ BUILTIN_INT16,
+ BUILTIN_INT32,
+ BUILTIN_INT64,
+ BUILTIN_U_INT8,
+ BUILTIN_U_INT16,
+ BUILTIN_U_INT32,
+ BUILTIN_U_INT64,
+ BUILTIN_FLOAT32,
+ BUILTIN_FLOAT64,
+ BUILTIN_TEXT,
+ BUILTIN_DATA,
+ BUILTIN_LIST,
+ BUILTIN_OBJECT,
+ BUILTIN_ANY_POINTER,
+ BUILTIN_ANY_STRUCT,
+ BUILTIN_ANY_LIST,
+ BUILTIN_CAPABILITY,
+ };
+ struct BrandParameter;
+ struct AnnotationApplication;
+ struct ParamList;
+ struct Param;
+ struct Id;
+ struct Using;
+ struct Const;
+ struct Field;
+ struct Interface;
+ struct Method;
+ struct Annotation;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(96efe787c17e83bb, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::BrandParameter {
+ BrandParameter() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(d5e71144af1ce175, 1, 1)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::AnnotationApplication {
+ AnnotationApplication() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ struct Value;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(d00489d473826290, 1, 2)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::AnnotationApplication::Value {
+ Value() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ NONE,
+ EXPRESSION,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(fb5aeed95cdf6af9, 1, 2)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::ParamList {
+ ParamList() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ NAMED_LIST,
+ TYPE,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(b3f66e7a79d81bcd, 2, 1)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Param {
+ Param() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ struct DefaultValue;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(fffe08a9a697d2a5, 2, 4)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Param::DefaultValue {
+ DefaultValue() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ NONE,
+ VALUE,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(e5104515fd88ea47, 2, 4)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Id {
+ Id() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ UNSPECIFIED,
+ UID,
+ ORDINAL,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(89f0c973c103ae96, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Using {
+ Using() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(e93164a80bfe2ccf, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Const {
+ Const() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(b348322a8dcf0d0c, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Field {
+ Field() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ struct DefaultValue;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(8f2622208fb358c8, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Field::DefaultValue {
+ DefaultValue() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ NONE,
+ VALUE,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(d0d1a21de617951f, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Interface {
+ Interface() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(992a90eaf30235d3, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Method {
+ Method() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ struct Results;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(eb971847d617c0b9, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Method::Results {
+ Results() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ NONE,
+ EXPLICIT,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(c6238c7d62d65173, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Declaration::Annotation {
+ Annotation() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(9cb9e86e3198037f, 2, 8)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct ParsedFile {
+ ParsedFile() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(84e4f3f5a807605c, 0, 1)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+// =======================================================================================
+
+class LocatedText::Reader {
+public:
+ typedef LocatedText 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 hasValue() const;
+ inline ::capnp::Text::Reader getValue() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class LocatedText::Builder {
+public:
+ typedef LocatedText 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 hasValue();
+ inline ::capnp::Text::Builder getValue();
+ inline void setValue( ::capnp::Text::Reader value);
+ inline ::capnp::Text::Builder initValue(unsigned int size);
+ inline void adoptValue(::capnp::Orphan< ::capnp::Text>&& value);
+ inline ::capnp::Orphan< ::capnp::Text> disownValue();
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class LocatedText::Pipeline {
+public:
+ typedef LocatedText 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class LocatedInteger::Reader {
+public:
+ typedef LocatedInteger 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 ::uint64_t getValue() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class LocatedInteger::Builder {
+public:
+ typedef LocatedInteger 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 ::uint64_t getValue();
+ inline void setValue( ::uint64_t value);
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class LocatedInteger::Pipeline {
+public:
+ typedef LocatedInteger 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class LocatedFloat::Reader {
+public:
+ typedef LocatedFloat 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 double getValue() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class LocatedFloat::Builder {
+public:
+ typedef LocatedFloat 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 double getValue();
+ inline void setValue(double value);
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class LocatedFloat::Pipeline {
+public:
+ typedef LocatedFloat 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Expression::Reader {
+public:
+ typedef Expression 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 Which which() const;
+ inline bool isUnknown() const;
+ inline ::capnp::Void getUnknown() const;
+
+ inline bool isPositiveInt() const;
+ inline ::uint64_t getPositiveInt() const;
+
+ inline bool isNegativeInt() const;
+ inline ::uint64_t getNegativeInt() const;
+
+ inline bool isFloat() const;
+ inline double getFloat() const;
+
+ inline bool isString() const;
+ inline bool hasString() const;
+ inline ::capnp::Text::Reader getString() const;
+
+ inline bool isRelativeName() const;
+ inline bool hasRelativeName() const;
+ inline ::capnp::compiler::LocatedText::Reader getRelativeName() const;
+
+ inline bool isList() const;
+ inline bool hasList() const;
+ inline ::capnp::List< ::capnp::compiler::Expression>::Reader getList() const;
+
+ inline bool isTuple() const;
+ inline bool hasTuple() const;
+ inline ::capnp::List< ::capnp::compiler::Expression::Param>::Reader getTuple() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+ inline bool isBinary() const;
+ inline bool hasBinary() const;
+ inline ::capnp::Data::Reader getBinary() const;
+
+ inline bool isApplication() const;
+ inline typename Application::Reader getApplication() const;
+
+ inline bool isMember() const;
+ inline typename Member::Reader getMember() const;
+
+ inline bool isAbsoluteName() const;
+ inline bool hasAbsoluteName() const;
+ inline ::capnp::compiler::LocatedText::Reader getAbsoluteName() const;
+
+ inline bool isImport() const;
+ inline bool hasImport() const;
+ inline ::capnp::compiler::LocatedText::Reader getImport() const;
+
+ inline bool isEmbed() const;
+ inline bool hasEmbed() const;
+ inline ::capnp::compiler::LocatedText::Reader getEmbed() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Expression::Builder {
+public:
+ typedef Expression 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 Which which();
+ inline bool isUnknown();
+ inline ::capnp::Void getUnknown();
+ inline void setUnknown( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isPositiveInt();
+ inline ::uint64_t getPositiveInt();
+ inline void setPositiveInt( ::uint64_t value);
+
+ inline bool isNegativeInt();
+ inline ::uint64_t getNegativeInt();
+ inline void setNegativeInt( ::uint64_t value);
+
+ inline bool isFloat();
+ inline double getFloat();
+ inline void setFloat(double value);
+
+ inline bool isString();
+ inline bool hasString();
+ inline ::capnp::Text::Builder getString();
+ inline void setString( ::capnp::Text::Reader value);
+ inline ::capnp::Text::Builder initString(unsigned int size);
+ inline void adoptString(::capnp::Orphan< ::capnp::Text>&& value);
+ inline ::capnp::Orphan< ::capnp::Text> disownString();
+
+ inline bool isRelativeName();
+ inline bool hasRelativeName();
+ inline ::capnp::compiler::LocatedText::Builder getRelativeName();
+ inline void setRelativeName( ::capnp::compiler::LocatedText::Reader value);
+ inline ::capnp::compiler::LocatedText::Builder initRelativeName();
+ inline void adoptRelativeName(::capnp::Orphan< ::capnp::compiler::LocatedText>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedText> disownRelativeName();
+
+ inline bool isList();
+ inline bool hasList();
+ inline ::capnp::List< ::capnp::compiler::Expression>::Builder getList();
+ inline void setList( ::capnp::List< ::capnp::compiler::Expression>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Expression>::Builder initList(unsigned int size);
+ inline void adoptList(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression>> disownList();
+
+ inline bool isTuple();
+ inline bool hasTuple();
+ inline ::capnp::List< ::capnp::compiler::Expression::Param>::Builder getTuple();
+ inline void setTuple( ::capnp::List< ::capnp::compiler::Expression::Param>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Expression::Param>::Builder initTuple(unsigned int size);
+ inline void adoptTuple(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression::Param>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression::Param>> disownTuple();
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+ inline bool isBinary();
+ inline bool hasBinary();
+ inline ::capnp::Data::Builder getBinary();
+ inline void setBinary( ::capnp::Data::Reader value);
+ inline ::capnp::Data::Builder initBinary(unsigned int size);
+ inline void adoptBinary(::capnp::Orphan< ::capnp::Data>&& value);
+ inline ::capnp::Orphan< ::capnp::Data> disownBinary();
+
+ inline bool isApplication();
+ inline typename Application::Builder getApplication();
+ inline typename Application::Builder initApplication();
+
+ inline bool isMember();
+ inline typename Member::Builder getMember();
+ inline typename Member::Builder initMember();
+
+ inline bool isAbsoluteName();
+ inline bool hasAbsoluteName();
+ inline ::capnp::compiler::LocatedText::Builder getAbsoluteName();
+ inline void setAbsoluteName( ::capnp::compiler::LocatedText::Reader value);
+ inline ::capnp::compiler::LocatedText::Builder initAbsoluteName();
+ inline void adoptAbsoluteName(::capnp::Orphan< ::capnp::compiler::LocatedText>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedText> disownAbsoluteName();
+
+ inline bool isImport();
+ inline bool hasImport();
+ inline ::capnp::compiler::LocatedText::Builder getImport();
+ inline void setImport( ::capnp::compiler::LocatedText::Reader value);
+ inline ::capnp::compiler::LocatedText::Builder initImport();
+ inline void adoptImport(::capnp::Orphan< ::capnp::compiler::LocatedText>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedText> disownImport();
+
+ inline bool isEmbed();
+ inline bool hasEmbed();
+ inline ::capnp::compiler::LocatedText::Builder getEmbed();
+ inline void setEmbed( ::capnp::compiler::LocatedText::Reader value);
+ inline ::capnp::compiler::LocatedText::Builder initEmbed();
+ inline void adoptEmbed(::capnp::Orphan< ::capnp::compiler::LocatedText>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedText> disownEmbed();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Expression::Pipeline {
+public:
+ typedef Expression 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Expression::Param::Reader {
+public:
+ typedef Param 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 Which which() const;
+ inline bool isUnnamed() const;
+ inline ::capnp::Void getUnnamed() const;
+
+ inline bool isNamed() const;
+ inline bool hasNamed() const;
+ inline ::capnp::compiler::LocatedText::Reader getNamed() const;
+
+ inline bool hasValue() const;
+ inline ::capnp::compiler::Expression::Reader getValue() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Expression::Param::Builder {
+public:
+ typedef Param 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 Which which();
+ inline bool isUnnamed();
+ inline ::capnp::Void getUnnamed();
+ inline void setUnnamed( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isNamed();
+ inline bool hasNamed();
+ inline ::capnp::compiler::LocatedText::Builder getNamed();
+ inline void setNamed( ::capnp::compiler::LocatedText::Reader value);
+ inline ::capnp::compiler::LocatedText::Builder initNamed();
+ inline void adoptNamed(::capnp::Orphan< ::capnp::compiler::LocatedText>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedText> disownNamed();
+
+ inline bool hasValue();
+ inline ::capnp::compiler::Expression::Builder getValue();
+ inline void setValue( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initValue();
+ inline void adoptValue(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownValue();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Expression::Param::Pipeline {
+public:
+ typedef Param Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Expression::Pipeline getValue();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Expression::Application::Reader {
+public:
+ typedef Application 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 hasFunction() const;
+ inline ::capnp::compiler::Expression::Reader getFunction() const;
+
+ inline bool hasParams() const;
+ inline ::capnp::List< ::capnp::compiler::Expression::Param>::Reader getParams() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Expression::Application::Builder {
+public:
+ typedef Application 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 hasFunction();
+ inline ::capnp::compiler::Expression::Builder getFunction();
+ inline void setFunction( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initFunction();
+ inline void adoptFunction(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownFunction();
+
+ inline bool hasParams();
+ inline ::capnp::List< ::capnp::compiler::Expression::Param>::Builder getParams();
+ inline void setParams( ::capnp::List< ::capnp::compiler::Expression::Param>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Expression::Param>::Builder initParams(unsigned int size);
+ inline void adoptParams(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression::Param>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression::Param>> disownParams();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Expression::Application::Pipeline {
+public:
+ typedef Application Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Expression::Pipeline getFunction();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Expression::Member::Reader {
+public:
+ typedef Member 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 hasParent() const;
+ inline ::capnp::compiler::Expression::Reader getParent() const;
+
+ inline bool hasName() const;
+ inline ::capnp::compiler::LocatedText::Reader getName() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Expression::Member::Builder {
+public:
+ typedef Member 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 hasParent();
+ inline ::capnp::compiler::Expression::Builder getParent();
+ inline void setParent( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initParent();
+ inline void adoptParent(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownParent();
+
+ inline bool hasName();
+ inline ::capnp::compiler::LocatedText::Builder getName();
+ inline void setName( ::capnp::compiler::LocatedText::Reader value);
+ inline ::capnp::compiler::LocatedText::Builder initName();
+ inline void adoptName(::capnp::Orphan< ::capnp::compiler::LocatedText>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedText> disownName();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Expression::Member::Pipeline {
+public:
+ typedef Member Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Expression::Pipeline getParent();
+ inline ::capnp::compiler::LocatedText::Pipeline getName();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Reader {
+public:
+ typedef Declaration 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 Which which() const;
+ inline bool hasName() const;
+ inline ::capnp::compiler::LocatedText::Reader getName() const;
+
+ inline typename Id::Reader getId() const;
+
+ inline bool hasNestedDecls() const;
+ inline ::capnp::List< ::capnp::compiler::Declaration>::Reader getNestedDecls() const;
+
+ inline bool hasAnnotations() const;
+ inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Reader getAnnotations() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+ inline bool hasDocComment() const;
+ inline ::capnp::Text::Reader getDocComment() const;
+
+ inline bool isFile() const;
+ inline ::capnp::Void getFile() const;
+
+ inline bool isUsing() const;
+ inline typename Using::Reader getUsing() const;
+
+ inline bool isConst() const;
+ inline typename Const::Reader getConst() const;
+
+ inline bool isEnum() const;
+ inline ::capnp::Void getEnum() const;
+
+ inline bool isEnumerant() const;
+ inline ::capnp::Void getEnumerant() const;
+
+ inline bool isStruct() const;
+ inline ::capnp::Void getStruct() const;
+
+ inline bool isField() const;
+ inline typename Field::Reader getField() const;
+
+ inline bool isUnion() const;
+ inline ::capnp::Void getUnion() const;
+
+ inline bool isGroup() const;
+ inline ::capnp::Void getGroup() const;
+
+ inline bool isInterface() const;
+ inline typename Interface::Reader getInterface() const;
+
+ inline bool isMethod() const;
+ inline typename Method::Reader getMethod() const;
+
+ inline bool isAnnotation() const;
+ inline typename Annotation::Reader getAnnotation() const;
+
+ inline bool isNakedId() const;
+ inline bool hasNakedId() const;
+ inline ::capnp::compiler::LocatedInteger::Reader getNakedId() const;
+
+ inline bool isNakedAnnotation() const;
+ inline bool hasNakedAnnotation() const;
+ inline ::capnp::compiler::Declaration::AnnotationApplication::Reader getNakedAnnotation() const;
+
+ inline bool isBuiltinVoid() const;
+ inline ::capnp::Void getBuiltinVoid() const;
+
+ inline bool isBuiltinBool() const;
+ inline ::capnp::Void getBuiltinBool() const;
+
+ inline bool isBuiltinInt8() const;
+ inline ::capnp::Void getBuiltinInt8() const;
+
+ inline bool isBuiltinInt16() const;
+ inline ::capnp::Void getBuiltinInt16() const;
+
+ inline bool isBuiltinInt32() const;
+ inline ::capnp::Void getBuiltinInt32() const;
+
+ inline bool isBuiltinInt64() const;
+ inline ::capnp::Void getBuiltinInt64() const;
+
+ inline bool isBuiltinUInt8() const;
+ inline ::capnp::Void getBuiltinUInt8() const;
+
+ inline bool isBuiltinUInt16() const;
+ inline ::capnp::Void getBuiltinUInt16() const;
+
+ inline bool isBuiltinUInt32() const;
+ inline ::capnp::Void getBuiltinUInt32() const;
+
+ inline bool isBuiltinUInt64() const;
+ inline ::capnp::Void getBuiltinUInt64() const;
+
+ inline bool isBuiltinFloat32() const;
+ inline ::capnp::Void getBuiltinFloat32() const;
+
+ inline bool isBuiltinFloat64() const;
+ inline ::capnp::Void getBuiltinFloat64() const;
+
+ inline bool isBuiltinText() const;
+ inline ::capnp::Void getBuiltinText() const;
+
+ inline bool isBuiltinData() const;
+ inline ::capnp::Void getBuiltinData() const;
+
+ inline bool isBuiltinList() const;
+ inline ::capnp::Void getBuiltinList() const;
+
+ inline bool isBuiltinObject() const;
+ inline ::capnp::Void getBuiltinObject() const;
+
+ inline bool isBuiltinAnyPointer() const;
+ inline ::capnp::Void getBuiltinAnyPointer() const;
+
+ inline bool hasParameters() const;
+ inline ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>::Reader getParameters() const;
+
+ inline bool isBuiltinAnyStruct() const;
+ inline ::capnp::Void getBuiltinAnyStruct() const;
+
+ inline bool isBuiltinAnyList() const;
+ inline ::capnp::Void getBuiltinAnyList() const;
+
+ inline bool isBuiltinCapability() const;
+ inline ::capnp::Void getBuiltinCapability() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Builder {
+public:
+ typedef Declaration 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 Which which();
+ inline bool hasName();
+ inline ::capnp::compiler::LocatedText::Builder getName();
+ inline void setName( ::capnp::compiler::LocatedText::Reader value);
+ inline ::capnp::compiler::LocatedText::Builder initName();
+ inline void adoptName(::capnp::Orphan< ::capnp::compiler::LocatedText>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedText> disownName();
+
+ inline typename Id::Builder getId();
+ inline typename Id::Builder initId();
+
+ inline bool hasNestedDecls();
+ inline ::capnp::List< ::capnp::compiler::Declaration>::Builder getNestedDecls();
+ inline void setNestedDecls( ::capnp::List< ::capnp::compiler::Declaration>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Declaration>::Builder initNestedDecls(unsigned int size);
+ inline void adoptNestedDecls(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration>> disownNestedDecls();
+
+ inline bool hasAnnotations();
+ inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Builder getAnnotations();
+ inline void setAnnotations( ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Builder initAnnotations(unsigned int size);
+ inline void adoptAnnotations(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>> disownAnnotations();
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+ inline bool hasDocComment();
+ inline ::capnp::Text::Builder getDocComment();
+ inline void setDocComment( ::capnp::Text::Reader value);
+ inline ::capnp::Text::Builder initDocComment(unsigned int size);
+ inline void adoptDocComment(::capnp::Orphan< ::capnp::Text>&& value);
+ inline ::capnp::Orphan< ::capnp::Text> disownDocComment();
+
+ inline bool isFile();
+ inline ::capnp::Void getFile();
+ inline void setFile( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isUsing();
+ inline typename Using::Builder getUsing();
+ inline typename Using::Builder initUsing();
+
+ inline bool isConst();
+ inline typename Const::Builder getConst();
+ inline typename Const::Builder initConst();
+
+ inline bool isEnum();
+ inline ::capnp::Void getEnum();
+ inline void setEnum( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isEnumerant();
+ inline ::capnp::Void getEnumerant();
+ inline void setEnumerant( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isStruct();
+ inline ::capnp::Void getStruct();
+ inline void setStruct( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isField();
+ inline typename Field::Builder getField();
+ inline typename Field::Builder initField();
+
+ inline bool isUnion();
+ inline ::capnp::Void getUnion();
+ inline void setUnion( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isGroup();
+ inline ::capnp::Void getGroup();
+ inline void setGroup( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isInterface();
+ inline typename Interface::Builder getInterface();
+ inline typename Interface::Builder initInterface();
+
+ inline bool isMethod();
+ inline typename Method::Builder getMethod();
+ inline typename Method::Builder initMethod();
+
+ inline bool isAnnotation();
+ inline typename Annotation::Builder getAnnotation();
+ inline typename Annotation::Builder initAnnotation();
+
+ inline bool isNakedId();
+ inline bool hasNakedId();
+ inline ::capnp::compiler::LocatedInteger::Builder getNakedId();
+ inline void setNakedId( ::capnp::compiler::LocatedInteger::Reader value);
+ inline ::capnp::compiler::LocatedInteger::Builder initNakedId();
+ inline void adoptNakedId(::capnp::Orphan< ::capnp::compiler::LocatedInteger>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedInteger> disownNakedId();
+
+ inline bool isNakedAnnotation();
+ inline bool hasNakedAnnotation();
+ inline ::capnp::compiler::Declaration::AnnotationApplication::Builder getNakedAnnotation();
+ inline void setNakedAnnotation( ::capnp::compiler::Declaration::AnnotationApplication::Reader value);
+ inline ::capnp::compiler::Declaration::AnnotationApplication::Builder initNakedAnnotation();
+ inline void adoptNakedAnnotation(::capnp::Orphan< ::capnp::compiler::Declaration::AnnotationApplication>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Declaration::AnnotationApplication> disownNakedAnnotation();
+
+ inline bool isBuiltinVoid();
+ inline ::capnp::Void getBuiltinVoid();
+ inline void setBuiltinVoid( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinBool();
+ inline ::capnp::Void getBuiltinBool();
+ inline void setBuiltinBool( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinInt8();
+ inline ::capnp::Void getBuiltinInt8();
+ inline void setBuiltinInt8( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinInt16();
+ inline ::capnp::Void getBuiltinInt16();
+ inline void setBuiltinInt16( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinInt32();
+ inline ::capnp::Void getBuiltinInt32();
+ inline void setBuiltinInt32( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinInt64();
+ inline ::capnp::Void getBuiltinInt64();
+ inline void setBuiltinInt64( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinUInt8();
+ inline ::capnp::Void getBuiltinUInt8();
+ inline void setBuiltinUInt8( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinUInt16();
+ inline ::capnp::Void getBuiltinUInt16();
+ inline void setBuiltinUInt16( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinUInt32();
+ inline ::capnp::Void getBuiltinUInt32();
+ inline void setBuiltinUInt32( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinUInt64();
+ inline ::capnp::Void getBuiltinUInt64();
+ inline void setBuiltinUInt64( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinFloat32();
+ inline ::capnp::Void getBuiltinFloat32();
+ inline void setBuiltinFloat32( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinFloat64();
+ inline ::capnp::Void getBuiltinFloat64();
+ inline void setBuiltinFloat64( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinText();
+ inline ::capnp::Void getBuiltinText();
+ inline void setBuiltinText( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinData();
+ inline ::capnp::Void getBuiltinData();
+ inline void setBuiltinData( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinList();
+ inline ::capnp::Void getBuiltinList();
+ inline void setBuiltinList( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinObject();
+ inline ::capnp::Void getBuiltinObject();
+ inline void setBuiltinObject( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinAnyPointer();
+ inline ::capnp::Void getBuiltinAnyPointer();
+ inline void setBuiltinAnyPointer( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool hasParameters();
+ inline ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>::Builder getParameters();
+ inline void setParameters( ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>::Builder initParameters(unsigned int size);
+ inline void adoptParameters(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>> disownParameters();
+
+ inline bool isBuiltinAnyStruct();
+ inline ::capnp::Void getBuiltinAnyStruct();
+ inline void setBuiltinAnyStruct( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinAnyList();
+ inline ::capnp::Void getBuiltinAnyList();
+ inline void setBuiltinAnyList( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBuiltinCapability();
+ inline ::capnp::Void getBuiltinCapability();
+ inline void setBuiltinCapability( ::capnp::Void value = ::capnp::VOID);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Pipeline {
+public:
+ typedef Declaration Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::LocatedText::Pipeline getName();
+ inline typename Id::Pipeline getId();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::BrandParameter::Reader {
+public:
+ typedef BrandParameter 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 hasName() const;
+ inline ::capnp::Text::Reader getName() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::BrandParameter::Builder {
+public:
+ typedef BrandParameter 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 hasName();
+ inline ::capnp::Text::Builder getName();
+ inline void setName( ::capnp::Text::Reader value);
+ inline ::capnp::Text::Builder initName(unsigned int size);
+ inline void adoptName(::capnp::Orphan< ::capnp::Text>&& value);
+ inline ::capnp::Orphan< ::capnp::Text> disownName();
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::BrandParameter::Pipeline {
+public:
+ typedef BrandParameter 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::AnnotationApplication::Reader {
+public:
+ typedef AnnotationApplication 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 hasName() const;
+ inline ::capnp::compiler::Expression::Reader getName() const;
+
+ inline typename Value::Reader getValue() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::AnnotationApplication::Builder {
+public:
+ typedef AnnotationApplication 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 hasName();
+ inline ::capnp::compiler::Expression::Builder getName();
+ inline void setName( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initName();
+ inline void adoptName(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownName();
+
+ inline typename Value::Builder getValue();
+ inline typename Value::Builder initValue();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::AnnotationApplication::Pipeline {
+public:
+ typedef AnnotationApplication Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Expression::Pipeline getName();
+ inline typename Value::Pipeline getValue();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::AnnotationApplication::Value::Reader {
+public:
+ typedef Value 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 Which which() const;
+ inline bool isNone() const;
+ inline ::capnp::Void getNone() const;
+
+ inline bool isExpression() const;
+ inline bool hasExpression() const;
+ inline ::capnp::compiler::Expression::Reader getExpression() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::AnnotationApplication::Value::Builder {
+public:
+ typedef Value 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 Which which();
+ inline bool isNone();
+ inline ::capnp::Void getNone();
+ inline void setNone( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isExpression();
+ inline bool hasExpression();
+ inline ::capnp::compiler::Expression::Builder getExpression();
+ inline void setExpression( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initExpression();
+ inline void adoptExpression(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownExpression();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::AnnotationApplication::Value::Pipeline {
+public:
+ typedef Value 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::ParamList::Reader {
+public:
+ typedef ParamList 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 Which which() const;
+ inline bool isNamedList() const;
+ inline bool hasNamedList() const;
+ inline ::capnp::List< ::capnp::compiler::Declaration::Param>::Reader getNamedList() const;
+
+ inline bool isType() const;
+ inline bool hasType() const;
+ inline ::capnp::compiler::Expression::Reader getType() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::ParamList::Builder {
+public:
+ typedef ParamList 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 Which which();
+ inline bool isNamedList();
+ inline bool hasNamedList();
+ inline ::capnp::List< ::capnp::compiler::Declaration::Param>::Builder getNamedList();
+ inline void setNamedList( ::capnp::List< ::capnp::compiler::Declaration::Param>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Declaration::Param>::Builder initNamedList(unsigned int size);
+ inline void adoptNamedList(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::Param>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::Param>> disownNamedList();
+
+ inline bool isType();
+ inline bool hasType();
+ inline ::capnp::compiler::Expression::Builder getType();
+ inline void setType( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initType();
+ inline void adoptType(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownType();
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::ParamList::Pipeline {
+public:
+ typedef ParamList 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Param::Reader {
+public:
+ typedef Param 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 hasName() const;
+ inline ::capnp::compiler::LocatedText::Reader getName() const;
+
+ inline bool hasType() const;
+ inline ::capnp::compiler::Expression::Reader getType() const;
+
+ inline bool hasAnnotations() const;
+ inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Reader getAnnotations() const;
+
+ inline typename DefaultValue::Reader getDefaultValue() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Param::Builder {
+public:
+ typedef Param 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 hasName();
+ inline ::capnp::compiler::LocatedText::Builder getName();
+ inline void setName( ::capnp::compiler::LocatedText::Reader value);
+ inline ::capnp::compiler::LocatedText::Builder initName();
+ inline void adoptName(::capnp::Orphan< ::capnp::compiler::LocatedText>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedText> disownName();
+
+ inline bool hasType();
+ inline ::capnp::compiler::Expression::Builder getType();
+ inline void setType( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initType();
+ inline void adoptType(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownType();
+
+ inline bool hasAnnotations();
+ inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Builder getAnnotations();
+ inline void setAnnotations( ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Builder initAnnotations(unsigned int size);
+ inline void adoptAnnotations(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>> disownAnnotations();
+
+ inline typename DefaultValue::Builder getDefaultValue();
+ inline typename DefaultValue::Builder initDefaultValue();
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Param::Pipeline {
+public:
+ typedef Param Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::LocatedText::Pipeline getName();
+ inline ::capnp::compiler::Expression::Pipeline getType();
+ inline typename DefaultValue::Pipeline getDefaultValue();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Param::DefaultValue::Reader {
+public:
+ typedef DefaultValue 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 Which which() const;
+ inline bool isNone() const;
+ inline ::capnp::Void getNone() const;
+
+ inline bool isValue() const;
+ inline bool hasValue() const;
+ inline ::capnp::compiler::Expression::Reader getValue() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Param::DefaultValue::Builder {
+public:
+ typedef DefaultValue 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 Which which();
+ inline bool isNone();
+ inline ::capnp::Void getNone();
+ inline void setNone( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isValue();
+ inline bool hasValue();
+ inline ::capnp::compiler::Expression::Builder getValue();
+ inline void setValue( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initValue();
+ inline void adoptValue(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownValue();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Param::DefaultValue::Pipeline {
+public:
+ typedef DefaultValue 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Id::Reader {
+public:
+ typedef Id 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 Which which() const;
+ inline bool isUnspecified() const;
+ inline ::capnp::Void getUnspecified() const;
+
+ inline bool isUid() const;
+ inline bool hasUid() const;
+ inline ::capnp::compiler::LocatedInteger::Reader getUid() const;
+
+ inline bool isOrdinal() const;
+ inline bool hasOrdinal() const;
+ inline ::capnp::compiler::LocatedInteger::Reader getOrdinal() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Id::Builder {
+public:
+ typedef Id 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 Which which();
+ inline bool isUnspecified();
+ inline ::capnp::Void getUnspecified();
+ inline void setUnspecified( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isUid();
+ inline bool hasUid();
+ inline ::capnp::compiler::LocatedInteger::Builder getUid();
+ inline void setUid( ::capnp::compiler::LocatedInteger::Reader value);
+ inline ::capnp::compiler::LocatedInteger::Builder initUid();
+ inline void adoptUid(::capnp::Orphan< ::capnp::compiler::LocatedInteger>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedInteger> disownUid();
+
+ inline bool isOrdinal();
+ inline bool hasOrdinal();
+ inline ::capnp::compiler::LocatedInteger::Builder getOrdinal();
+ inline void setOrdinal( ::capnp::compiler::LocatedInteger::Reader value);
+ inline ::capnp::compiler::LocatedInteger::Builder initOrdinal();
+ inline void adoptOrdinal(::capnp::Orphan< ::capnp::compiler::LocatedInteger>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::LocatedInteger> disownOrdinal();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Id::Pipeline {
+public:
+ typedef Id 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Using::Reader {
+public:
+ typedef Using 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 hasTarget() const;
+ inline ::capnp::compiler::Expression::Reader getTarget() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Using::Builder {
+public:
+ typedef Using 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 hasTarget();
+ inline ::capnp::compiler::Expression::Builder getTarget();
+ inline void setTarget( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initTarget();
+ inline void adoptTarget(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownTarget();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Using::Pipeline {
+public:
+ typedef Using Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Expression::Pipeline getTarget();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Const::Reader {
+public:
+ typedef Const 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 hasType() const;
+ inline ::capnp::compiler::Expression::Reader getType() const;
+
+ inline bool hasValue() const;
+ inline ::capnp::compiler::Expression::Reader getValue() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Const::Builder {
+public:
+ typedef Const 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 hasType();
+ inline ::capnp::compiler::Expression::Builder getType();
+ inline void setType( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initType();
+ inline void adoptType(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownType();
+
+ inline bool hasValue();
+ inline ::capnp::compiler::Expression::Builder getValue();
+ inline void setValue( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initValue();
+ inline void adoptValue(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownValue();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Const::Pipeline {
+public:
+ typedef Const Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Expression::Pipeline getType();
+ inline ::capnp::compiler::Expression::Pipeline getValue();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Field::Reader {
+public:
+ typedef Field 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 hasType() const;
+ inline ::capnp::compiler::Expression::Reader getType() const;
+
+ inline typename DefaultValue::Reader getDefaultValue() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Field::Builder {
+public:
+ typedef Field 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 hasType();
+ inline ::capnp::compiler::Expression::Builder getType();
+ inline void setType( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initType();
+ inline void adoptType(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownType();
+
+ inline typename DefaultValue::Builder getDefaultValue();
+ inline typename DefaultValue::Builder initDefaultValue();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Field::Pipeline {
+public:
+ typedef Field Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Expression::Pipeline getType();
+ inline typename DefaultValue::Pipeline getDefaultValue();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Field::DefaultValue::Reader {
+public:
+ typedef DefaultValue 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 Which which() const;
+ inline bool isNone() const;
+ inline ::capnp::Void getNone() const;
+
+ inline bool isValue() const;
+ inline bool hasValue() const;
+ inline ::capnp::compiler::Expression::Reader getValue() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Field::DefaultValue::Builder {
+public:
+ typedef DefaultValue 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 Which which();
+ inline bool isNone();
+ inline ::capnp::Void getNone();
+ inline void setNone( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isValue();
+ inline bool hasValue();
+ inline ::capnp::compiler::Expression::Builder getValue();
+ inline void setValue( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initValue();
+ inline void adoptValue(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownValue();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Field::DefaultValue::Pipeline {
+public:
+ typedef DefaultValue 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Interface::Reader {
+public:
+ typedef Interface 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 hasSuperclasses() const;
+ inline ::capnp::List< ::capnp::compiler::Expression>::Reader getSuperclasses() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Interface::Builder {
+public:
+ typedef Interface 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 hasSuperclasses();
+ inline ::capnp::List< ::capnp::compiler::Expression>::Builder getSuperclasses();
+ inline void setSuperclasses( ::capnp::List< ::capnp::compiler::Expression>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Expression>::Builder initSuperclasses(unsigned int size);
+ inline void adoptSuperclasses(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression>> disownSuperclasses();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Interface::Pipeline {
+public:
+ typedef Interface 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Method::Reader {
+public:
+ typedef Method 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 hasParams() const;
+ inline ::capnp::compiler::Declaration::ParamList::Reader getParams() const;
+
+ inline typename Results::Reader getResults() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Method::Builder {
+public:
+ typedef Method 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 hasParams();
+ inline ::capnp::compiler::Declaration::ParamList::Builder getParams();
+ inline void setParams( ::capnp::compiler::Declaration::ParamList::Reader value);
+ inline ::capnp::compiler::Declaration::ParamList::Builder initParams();
+ inline void adoptParams(::capnp::Orphan< ::capnp::compiler::Declaration::ParamList>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Declaration::ParamList> disownParams();
+
+ inline typename Results::Builder getResults();
+ inline typename Results::Builder initResults();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Method::Pipeline {
+public:
+ typedef Method Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Declaration::ParamList::Pipeline getParams();
+ inline typename Results::Pipeline getResults();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Method::Results::Reader {
+public:
+ typedef Results 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 Which which() const;
+ inline bool isNone() const;
+ inline ::capnp::Void getNone() const;
+
+ inline bool isExplicit() const;
+ inline bool hasExplicit() const;
+ inline ::capnp::compiler::Declaration::ParamList::Reader getExplicit() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Method::Results::Builder {
+public:
+ typedef Results 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 Which which();
+ inline bool isNone();
+ inline ::capnp::Void getNone();
+ inline void setNone( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isExplicit();
+ inline bool hasExplicit();
+ inline ::capnp::compiler::Declaration::ParamList::Builder getExplicit();
+ inline void setExplicit( ::capnp::compiler::Declaration::ParamList::Reader value);
+ inline ::capnp::compiler::Declaration::ParamList::Builder initExplicit();
+ inline void adoptExplicit(::capnp::Orphan< ::capnp::compiler::Declaration::ParamList>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Declaration::ParamList> disownExplicit();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Method::Results::Pipeline {
+public:
+ typedef Results 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Declaration::Annotation::Reader {
+public:
+ typedef Annotation 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 hasType() const;
+ inline ::capnp::compiler::Expression::Reader getType() const;
+
+ inline bool getTargetsFile() const;
+
+ inline bool getTargetsConst() const;
+
+ inline bool getTargetsEnum() const;
+
+ inline bool getTargetsEnumerant() const;
+
+ inline bool getTargetsStruct() const;
+
+ inline bool getTargetsField() const;
+
+ inline bool getTargetsUnion() const;
+
+ inline bool getTargetsGroup() const;
+
+ inline bool getTargetsInterface() const;
+
+ inline bool getTargetsMethod() const;
+
+ inline bool getTargetsParam() const;
+
+ inline bool getTargetsAnnotation() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Declaration::Annotation::Builder {
+public:
+ typedef Annotation 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 hasType();
+ inline ::capnp::compiler::Expression::Builder getType();
+ inline void setType( ::capnp::compiler::Expression::Reader value);
+ inline ::capnp::compiler::Expression::Builder initType();
+ inline void adoptType(::capnp::Orphan< ::capnp::compiler::Expression>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Expression> disownType();
+
+ inline bool getTargetsFile();
+ inline void setTargetsFile(bool value);
+
+ inline bool getTargetsConst();
+ inline void setTargetsConst(bool value);
+
+ inline bool getTargetsEnum();
+ inline void setTargetsEnum(bool value);
+
+ inline bool getTargetsEnumerant();
+ inline void setTargetsEnumerant(bool value);
+
+ inline bool getTargetsStruct();
+ inline void setTargetsStruct(bool value);
+
+ inline bool getTargetsField();
+ inline void setTargetsField(bool value);
+
+ inline bool getTargetsUnion();
+ inline void setTargetsUnion(bool value);
+
+ inline bool getTargetsGroup();
+ inline void setTargetsGroup(bool value);
+
+ inline bool getTargetsInterface();
+ inline void setTargetsInterface(bool value);
+
+ inline bool getTargetsMethod();
+ inline void setTargetsMethod(bool value);
+
+ inline bool getTargetsParam();
+ inline void setTargetsParam(bool value);
+
+ inline bool getTargetsAnnotation();
+ inline void setTargetsAnnotation(bool value);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Declaration::Annotation::Pipeline {
+public:
+ typedef Annotation Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Expression::Pipeline getType();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class ParsedFile::Reader {
+public:
+ typedef ParsedFile 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 hasRoot() const;
+ inline ::capnp::compiler::Declaration::Reader getRoot() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class ParsedFile::Builder {
+public:
+ typedef ParsedFile 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 hasRoot();
+ inline ::capnp::compiler::Declaration::Builder getRoot();
+ inline void setRoot( ::capnp::compiler::Declaration::Reader value);
+ inline ::capnp::compiler::Declaration::Builder initRoot();
+ inline void adoptRoot(::capnp::Orphan< ::capnp::compiler::Declaration>&& value);
+ inline ::capnp::Orphan< ::capnp::compiler::Declaration> disownRoot();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class ParsedFile::Pipeline {
+public:
+ typedef ParsedFile Pipelines;
+
+ inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
+ inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
+ : _typeless(kj::mv(typeless)) {}
+
+ inline ::capnp::compiler::Declaration::Pipeline getRoot();
+private:
+ ::capnp::AnyPointer::Pipeline _typeless;
+ friend class ::capnp::PipelineHook;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+// =======================================================================================
+
+inline bool LocatedText::Reader::hasValue() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool LocatedText::Builder::hasValue() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Text::Reader LocatedText::Reader::getValue() const {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::Text::Builder LocatedText::Builder::getValue() {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void LocatedText::Builder::setValue( ::capnp::Text::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Text::Builder LocatedText::Builder::initValue(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void LocatedText::Builder::adoptValue(
+ ::capnp::Orphan< ::capnp::Text>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Text> LocatedText::Builder::disownValue() {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline ::uint32_t LocatedText::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t LocatedText::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void LocatedText::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t LocatedText::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t LocatedText::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void LocatedText::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint64_t LocatedInteger::Reader::getValue() const {
+ return _reader.getDataField< ::uint64_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint64_t LocatedInteger::Builder::getValue() {
+ return _builder.getDataField< ::uint64_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void LocatedInteger::Builder::setValue( ::uint64_t value) {
+ _builder.setDataField< ::uint64_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t LocatedInteger::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t LocatedInteger::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+inline void LocatedInteger::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t LocatedInteger::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<3>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t LocatedInteger::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<3>() * ::capnp::ELEMENTS);
+}
+inline void LocatedInteger::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
+}
+
+inline double LocatedFloat::Reader::getValue() const {
+ return _reader.getDataField<double>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline double LocatedFloat::Builder::getValue() {
+ return _builder.getDataField<double>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void LocatedFloat::Builder::setValue(double value) {
+ _builder.setDataField<double>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t LocatedFloat::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t LocatedFloat::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+inline void LocatedFloat::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t LocatedFloat::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<3>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t LocatedFloat::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<3>() * ::capnp::ELEMENTS);
+}
+inline void LocatedFloat::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<3>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::capnp::compiler::Expression::Which Expression::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Expression::Which Expression::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline bool Expression::Reader::isUnknown() const {
+ return which() == Expression::UNKNOWN;
+}
+inline bool Expression::Builder::isUnknown() {
+ return which() == Expression::UNKNOWN;
+}
+inline ::capnp::Void Expression::Reader::getUnknown() const {
+ KJ_IREQUIRE((which() == Expression::UNKNOWN),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Expression::Builder::getUnknown() {
+ KJ_IREQUIRE((which() == Expression::UNKNOWN),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Expression::Builder::setUnknown( ::capnp::Void value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::UNKNOWN);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Expression::Reader::isPositiveInt() const {
+ return which() == Expression::POSITIVE_INT;
+}
+inline bool Expression::Builder::isPositiveInt() {
+ return which() == Expression::POSITIVE_INT;
+}
+inline ::uint64_t Expression::Reader::getPositiveInt() const {
+ KJ_IREQUIRE((which() == Expression::POSITIVE_INT),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint64_t Expression::Builder::getPositiveInt() {
+ KJ_IREQUIRE((which() == Expression::POSITIVE_INT),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Expression::Builder::setPositiveInt( ::uint64_t value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::POSITIVE_INT);
+ _builder.setDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Expression::Reader::isNegativeInt() const {
+ return which() == Expression::NEGATIVE_INT;
+}
+inline bool Expression::Builder::isNegativeInt() {
+ return which() == Expression::NEGATIVE_INT;
+}
+inline ::uint64_t Expression::Reader::getNegativeInt() const {
+ KJ_IREQUIRE((which() == Expression::NEGATIVE_INT),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint64_t Expression::Builder::getNegativeInt() {
+ KJ_IREQUIRE((which() == Expression::NEGATIVE_INT),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Expression::Builder::setNegativeInt( ::uint64_t value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::NEGATIVE_INT);
+ _builder.setDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Expression::Reader::isFloat() const {
+ return which() == Expression::FLOAT;
+}
+inline bool Expression::Builder::isFloat() {
+ return which() == Expression::FLOAT;
+}
+inline double Expression::Reader::getFloat() const {
+ KJ_IREQUIRE((which() == Expression::FLOAT),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField<double>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline double Expression::Builder::getFloat() {
+ KJ_IREQUIRE((which() == Expression::FLOAT),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField<double>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Expression::Builder::setFloat(double value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::FLOAT);
+ _builder.setDataField<double>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Expression::Reader::isString() const {
+ return which() == Expression::STRING;
+}
+inline bool Expression::Builder::isString() {
+ return which() == Expression::STRING;
+}
+inline bool Expression::Reader::hasString() const {
+ if (which() != Expression::STRING) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Builder::hasString() {
+ if (which() != Expression::STRING) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Text::Reader Expression::Reader::getString() const {
+ KJ_IREQUIRE((which() == Expression::STRING),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::Text::Builder Expression::Builder::getString() {
+ KJ_IREQUIRE((which() == Expression::STRING),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::setString( ::capnp::Text::Reader value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::STRING);
+ ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Text::Builder Expression::Builder::initString(unsigned int size) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::STRING);
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Expression::Builder::adoptString(
+ ::capnp::Orphan< ::capnp::Text>&& value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::STRING);
+ ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Text> Expression::Builder::disownString() {
+ KJ_IREQUIRE((which() == Expression::STRING),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Reader::isRelativeName() const {
+ return which() == Expression::RELATIVE_NAME;
+}
+inline bool Expression::Builder::isRelativeName() {
+ return which() == Expression::RELATIVE_NAME;
+}
+inline bool Expression::Reader::hasRelativeName() const {
+ if (which() != Expression::RELATIVE_NAME) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Builder::hasRelativeName() {
+ if (which() != Expression::RELATIVE_NAME) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedText::Reader Expression::Reader::getRelativeName() const {
+ KJ_IREQUIRE((which() == Expression::RELATIVE_NAME),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Builder::getRelativeName() {
+ KJ_IREQUIRE((which() == Expression::RELATIVE_NAME),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::setRelativeName( ::capnp::compiler::LocatedText::Reader value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::RELATIVE_NAME);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Builder::initRelativeName() {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::RELATIVE_NAME);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::adoptRelativeName(
+ ::capnp::Orphan< ::capnp::compiler::LocatedText>&& value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::RELATIVE_NAME);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedText> Expression::Builder::disownRelativeName() {
+ KJ_IREQUIRE((which() == Expression::RELATIVE_NAME),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Reader::isList() const {
+ return which() == Expression::LIST;
+}
+inline bool Expression::Builder::isList() {
+ return which() == Expression::LIST;
+}
+inline bool Expression::Reader::hasList() const {
+ if (which() != Expression::LIST) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Builder::hasList() {
+ if (which() != Expression::LIST) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Expression>::Reader Expression::Reader::getList() const {
+ KJ_IREQUIRE((which() == Expression::LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Expression>::Builder Expression::Builder::getList() {
+ KJ_IREQUIRE((which() == Expression::LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::setList( ::capnp::List< ::capnp::compiler::Expression>::Reader value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Expression>::Builder Expression::Builder::initList(unsigned int size) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::LIST);
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Expression::Builder::adoptList(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression>>&& value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression>> Expression::Builder::disownList() {
+ KJ_IREQUIRE((which() == Expression::LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Reader::isTuple() const {
+ return which() == Expression::TUPLE;
+}
+inline bool Expression::Builder::isTuple() {
+ return which() == Expression::TUPLE;
+}
+inline bool Expression::Reader::hasTuple() const {
+ if (which() != Expression::TUPLE) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Builder::hasTuple() {
+ if (which() != Expression::TUPLE) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Expression::Param>::Reader Expression::Reader::getTuple() const {
+ KJ_IREQUIRE((which() == Expression::TUPLE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Expression::Param>::Builder Expression::Builder::getTuple() {
+ KJ_IREQUIRE((which() == Expression::TUPLE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::setTuple( ::capnp::List< ::capnp::compiler::Expression::Param>::Reader value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::TUPLE);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Expression::Param>::Builder Expression::Builder::initTuple(unsigned int size) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::TUPLE);
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Expression::Builder::adoptTuple(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression::Param>>&& value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::TUPLE);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression::Param>> Expression::Builder::disownTuple() {
+ KJ_IREQUIRE((which() == Expression::TUPLE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline ::uint32_t Expression::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Expression::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Expression::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t Expression::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<4>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Expression::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<4>() * ::capnp::ELEMENTS);
+}
+inline void Expression::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Expression::Reader::isBinary() const {
+ return which() == Expression::BINARY;
+}
+inline bool Expression::Builder::isBinary() {
+ return which() == Expression::BINARY;
+}
+inline bool Expression::Reader::hasBinary() const {
+ if (which() != Expression::BINARY) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Builder::hasBinary() {
+ if (which() != Expression::BINARY) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Data::Reader Expression::Reader::getBinary() const {
+ KJ_IREQUIRE((which() == Expression::BINARY),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::Data::Builder Expression::Builder::getBinary() {
+ KJ_IREQUIRE((which() == Expression::BINARY),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::setBinary( ::capnp::Data::Reader value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::BINARY);
+ ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Data::Builder Expression::Builder::initBinary(unsigned int size) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::BINARY);
+ return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Expression::Builder::adoptBinary(
+ ::capnp::Orphan< ::capnp::Data>&& value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::BINARY);
+ ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Data> Expression::Builder::disownBinary() {
+ KJ_IREQUIRE((which() == Expression::BINARY),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Reader::isApplication() const {
+ return which() == Expression::APPLICATION;
+}
+inline bool Expression::Builder::isApplication() {
+ return which() == Expression::APPLICATION;
+}
+inline typename Expression::Application::Reader Expression::Reader::getApplication() const {
+ KJ_IREQUIRE((which() == Expression::APPLICATION),
+ "Must check which() before get()ing a union member.");
+ return typename Expression::Application::Reader(_reader);
+}
+inline typename Expression::Application::Builder Expression::Builder::getApplication() {
+ KJ_IREQUIRE((which() == Expression::APPLICATION),
+ "Must check which() before get()ing a union member.");
+ return typename Expression::Application::Builder(_builder);
+}
+inline typename Expression::Application::Builder Expression::Builder::initApplication() {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::APPLICATION);
+ _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear();
+ _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear();
+ return typename Expression::Application::Builder(_builder);
+}
+inline bool Expression::Reader::isMember() const {
+ return which() == Expression::MEMBER;
+}
+inline bool Expression::Builder::isMember() {
+ return which() == Expression::MEMBER;
+}
+inline typename Expression::Member::Reader Expression::Reader::getMember() const {
+ KJ_IREQUIRE((which() == Expression::MEMBER),
+ "Must check which() before get()ing a union member.");
+ return typename Expression::Member::Reader(_reader);
+}
+inline typename Expression::Member::Builder Expression::Builder::getMember() {
+ KJ_IREQUIRE((which() == Expression::MEMBER),
+ "Must check which() before get()ing a union member.");
+ return typename Expression::Member::Builder(_builder);
+}
+inline typename Expression::Member::Builder Expression::Builder::initMember() {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::MEMBER);
+ _builder.getPointerField(::capnp::bounded<0>() * ::capnp::POINTERS).clear();
+ _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear();
+ return typename Expression::Member::Builder(_builder);
+}
+inline bool Expression::Reader::isAbsoluteName() const {
+ return which() == Expression::ABSOLUTE_NAME;
+}
+inline bool Expression::Builder::isAbsoluteName() {
+ return which() == Expression::ABSOLUTE_NAME;
+}
+inline bool Expression::Reader::hasAbsoluteName() const {
+ if (which() != Expression::ABSOLUTE_NAME) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Builder::hasAbsoluteName() {
+ if (which() != Expression::ABSOLUTE_NAME) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedText::Reader Expression::Reader::getAbsoluteName() const {
+ KJ_IREQUIRE((which() == Expression::ABSOLUTE_NAME),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Builder::getAbsoluteName() {
+ KJ_IREQUIRE((which() == Expression::ABSOLUTE_NAME),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::setAbsoluteName( ::capnp::compiler::LocatedText::Reader value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::ABSOLUTE_NAME);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Builder::initAbsoluteName() {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::ABSOLUTE_NAME);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::adoptAbsoluteName(
+ ::capnp::Orphan< ::capnp::compiler::LocatedText>&& value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::ABSOLUTE_NAME);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedText> Expression::Builder::disownAbsoluteName() {
+ KJ_IREQUIRE((which() == Expression::ABSOLUTE_NAME),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Reader::isImport() const {
+ return which() == Expression::IMPORT;
+}
+inline bool Expression::Builder::isImport() {
+ return which() == Expression::IMPORT;
+}
+inline bool Expression::Reader::hasImport() const {
+ if (which() != Expression::IMPORT) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Builder::hasImport() {
+ if (which() != Expression::IMPORT) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedText::Reader Expression::Reader::getImport() const {
+ KJ_IREQUIRE((which() == Expression::IMPORT),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Builder::getImport() {
+ KJ_IREQUIRE((which() == Expression::IMPORT),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::setImport( ::capnp::compiler::LocatedText::Reader value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::IMPORT);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Builder::initImport() {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::IMPORT);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::adoptImport(
+ ::capnp::Orphan< ::capnp::compiler::LocatedText>&& value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::IMPORT);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedText> Expression::Builder::disownImport() {
+ KJ_IREQUIRE((which() == Expression::IMPORT),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Reader::isEmbed() const {
+ return which() == Expression::EMBED;
+}
+inline bool Expression::Builder::isEmbed() {
+ return which() == Expression::EMBED;
+}
+inline bool Expression::Reader::hasEmbed() const {
+ if (which() != Expression::EMBED) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Builder::hasEmbed() {
+ if (which() != Expression::EMBED) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedText::Reader Expression::Reader::getEmbed() const {
+ KJ_IREQUIRE((which() == Expression::EMBED),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Builder::getEmbed() {
+ KJ_IREQUIRE((which() == Expression::EMBED),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::setEmbed( ::capnp::compiler::LocatedText::Reader value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::EMBED);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Builder::initEmbed() {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::EMBED);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Builder::adoptEmbed(
+ ::capnp::Orphan< ::capnp::compiler::LocatedText>&& value) {
+ _builder.setDataField<Expression::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::EMBED);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedText> Expression::Builder::disownEmbed() {
+ KJ_IREQUIRE((which() == Expression::EMBED),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline ::capnp::compiler::Expression::Param::Which Expression::Param::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Expression::Param::Which Expression::Param::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline bool Expression::Param::Reader::isUnnamed() const {
+ return which() == Expression::Param::UNNAMED;
+}
+inline bool Expression::Param::Builder::isUnnamed() {
+ return which() == Expression::Param::UNNAMED;
+}
+inline ::capnp::Void Expression::Param::Reader::getUnnamed() const {
+ KJ_IREQUIRE((which() == Expression::Param::UNNAMED),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Expression::Param::Builder::getUnnamed() {
+ KJ_IREQUIRE((which() == Expression::Param::UNNAMED),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Expression::Param::Builder::setUnnamed( ::capnp::Void value) {
+ _builder.setDataField<Expression::Param::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::Param::UNNAMED);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Expression::Param::Reader::isNamed() const {
+ return which() == Expression::Param::NAMED;
+}
+inline bool Expression::Param::Builder::isNamed() {
+ return which() == Expression::Param::NAMED;
+}
+inline bool Expression::Param::Reader::hasNamed() const {
+ if (which() != Expression::Param::NAMED) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Param::Builder::hasNamed() {
+ if (which() != Expression::Param::NAMED) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedText::Reader Expression::Param::Reader::getNamed() const {
+ KJ_IREQUIRE((which() == Expression::Param::NAMED),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Param::Builder::getNamed() {
+ KJ_IREQUIRE((which() == Expression::Param::NAMED),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Param::Builder::setNamed( ::capnp::compiler::LocatedText::Reader value) {
+ _builder.setDataField<Expression::Param::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::Param::NAMED);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Param::Builder::initNamed() {
+ _builder.setDataField<Expression::Param::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::Param::NAMED);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Param::Builder::adoptNamed(
+ ::capnp::Orphan< ::capnp::compiler::LocatedText>&& value) {
+ _builder.setDataField<Expression::Param::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Expression::Param::NAMED);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedText> Expression::Param::Builder::disownNamed() {
+ KJ_IREQUIRE((which() == Expression::Param::NAMED),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Param::Reader::hasValue() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Param::Builder::hasValue() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Expression::Param::Reader::getValue() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Expression::Param::Builder::getValue() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Expression::Param::Pipeline::getValue() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(1));
+}
+#endif // !CAPNP_LITE
+inline void Expression::Param::Builder::setValue( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Expression::Param::Builder::initValue() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Expression::Param::Builder::adoptValue(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Expression::Param::Builder::disownValue() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Application::Reader::hasFunction() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Application::Builder::hasFunction() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Expression::Application::Reader::getFunction() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Expression::Application::Builder::getFunction() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Expression::Application::Pipeline::getFunction() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(0));
+}
+#endif // !CAPNP_LITE
+inline void Expression::Application::Builder::setFunction( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Expression::Application::Builder::initFunction() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Application::Builder::adoptFunction(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Expression::Application::Builder::disownFunction() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Application::Reader::hasParams() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Application::Builder::hasParams() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Expression::Param>::Reader Expression::Application::Reader::getParams() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::get(_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Expression::Param>::Builder Expression::Application::Builder::getParams() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::get(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Expression::Application::Builder::setParams( ::capnp::List< ::capnp::compiler::Expression::Param>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::set(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Expression::Param>::Builder Expression::Application::Builder::initParams(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::init(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), size);
+}
+inline void Expression::Application::Builder::adoptParams(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression::Param>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression::Param>> Expression::Application::Builder::disownParams() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression::Param>>::disown(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Member::Reader::hasParent() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Member::Builder::hasParent() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Expression::Member::Reader::getParent() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Expression::Member::Builder::getParent() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Expression::Member::Pipeline::getParent() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(0));
+}
+#endif // !CAPNP_LITE
+inline void Expression::Member::Builder::setParent( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Expression::Member::Builder::initParent() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Expression::Member::Builder::adoptParent(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Expression::Member::Builder::disownParent() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Expression::Member::Reader::hasName() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline bool Expression::Member::Builder::hasName() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedText::Reader Expression::Member::Reader::getName() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Member::Builder::getName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::LocatedText::Pipeline Expression::Member::Pipeline::getName() {
+ return ::capnp::compiler::LocatedText::Pipeline(_typeless.getPointerField(1));
+}
+#endif // !CAPNP_LITE
+inline void Expression::Member::Builder::setName( ::capnp::compiler::LocatedText::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::set(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedText::Builder Expression::Member::Builder::initName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::init(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Expression::Member::Builder::adoptName(
+ ::capnp::Orphan< ::capnp::compiler::LocatedText>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::adopt(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedText> Expression::Member::Builder::disownName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::disown(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+
+inline ::capnp::compiler::Declaration::Which Declaration::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Declaration::Which Declaration::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Reader::hasName() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Builder::hasName() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedText::Reader Declaration::Reader::getName() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedText::Builder Declaration::Builder::getName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::LocatedText::Pipeline Declaration::Pipeline::getName() {
+ return ::capnp::compiler::LocatedText::Pipeline(_typeless.getPointerField(0));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Builder::setName( ::capnp::compiler::LocatedText::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedText::Builder Declaration::Builder::initName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::adoptName(
+ ::capnp::Orphan< ::capnp::compiler::LocatedText>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedText> Declaration::Builder::disownName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline typename Declaration::Id::Reader Declaration::Reader::getId() const {
+ return typename Declaration::Id::Reader(_reader);
+}
+inline typename Declaration::Id::Builder Declaration::Builder::getId() {
+ return typename Declaration::Id::Builder(_builder);
+}
+#if !CAPNP_LITE
+inline typename Declaration::Id::Pipeline Declaration::Pipeline::getId() {
+ return typename Declaration::Id::Pipeline(_typeless.noop());
+}
+#endif // !CAPNP_LITE
+inline typename Declaration::Id::Builder Declaration::Builder::initId() {
+ _builder.setDataField< ::uint16_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0);
+ _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Id::Builder(_builder);
+}
+inline bool Declaration::Reader::hasNestedDecls() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Builder::hasNestedDecls() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Declaration>::Reader Declaration::Reader::getNestedDecls() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration>>::get(_reader.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Declaration>::Builder Declaration::Builder::getNestedDecls() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration>>::get(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::setNestedDecls( ::capnp::List< ::capnp::compiler::Declaration>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration>>::set(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Declaration>::Builder Declaration::Builder::initNestedDecls(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration>>::init(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), size);
+}
+inline void Declaration::Builder::adoptNestedDecls(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration>> Declaration::Builder::disownNestedDecls() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration>>::disown(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Reader::hasAnnotations() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Builder::hasAnnotations() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Reader Declaration::Reader::getAnnotations() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::get(_reader.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Builder Declaration::Builder::getAnnotations() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::get(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::setAnnotations( ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::set(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Builder Declaration::Builder::initAnnotations(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::init(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS), size);
+}
+inline void Declaration::Builder::adoptAnnotations(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>> Declaration::Builder::disownAnnotations() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::disown(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS));
+}
+
+inline ::uint32_t Declaration::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Declaration::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t Declaration::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Declaration::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::hasDocComment() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Builder::hasDocComment() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<4>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Text::Reader Declaration::Reader::getDocComment() const {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
+ ::capnp::bounded<4>() * ::capnp::POINTERS));
+}
+inline ::capnp::Text::Builder Declaration::Builder::getDocComment() {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
+ ::capnp::bounded<4>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::setDocComment( ::capnp::Text::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
+ ::capnp::bounded<4>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Text::Builder Declaration::Builder::initDocComment(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
+ ::capnp::bounded<4>() * ::capnp::POINTERS), size);
+}
+inline void Declaration::Builder::adoptDocComment(
+ ::capnp::Orphan< ::capnp::Text>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
+ ::capnp::bounded<4>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Text> Declaration::Builder::disownDocComment() {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
+ ::capnp::bounded<4>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Reader::isFile() const {
+ return which() == Declaration::FILE;
+}
+inline bool Declaration::Builder::isFile() {
+ return which() == Declaration::FILE;
+}
+inline ::capnp::Void Declaration::Reader::getFile() const {
+ KJ_IREQUIRE((which() == Declaration::FILE),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getFile() {
+ KJ_IREQUIRE((which() == Declaration::FILE),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setFile( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::FILE);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isUsing() const {
+ return which() == Declaration::USING;
+}
+inline bool Declaration::Builder::isUsing() {
+ return which() == Declaration::USING;
+}
+inline typename Declaration::Using::Reader Declaration::Reader::getUsing() const {
+ KJ_IREQUIRE((which() == Declaration::USING),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Using::Reader(_reader);
+}
+inline typename Declaration::Using::Builder Declaration::Builder::getUsing() {
+ KJ_IREQUIRE((which() == Declaration::USING),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Using::Builder(_builder);
+}
+inline typename Declaration::Using::Builder Declaration::Builder::initUsing() {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::USING);
+ _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Using::Builder(_builder);
+}
+inline bool Declaration::Reader::isConst() const {
+ return which() == Declaration::CONST;
+}
+inline bool Declaration::Builder::isConst() {
+ return which() == Declaration::CONST;
+}
+inline typename Declaration::Const::Reader Declaration::Reader::getConst() const {
+ KJ_IREQUIRE((which() == Declaration::CONST),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Const::Reader(_reader);
+}
+inline typename Declaration::Const::Builder Declaration::Builder::getConst() {
+ KJ_IREQUIRE((which() == Declaration::CONST),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Const::Builder(_builder);
+}
+inline typename Declaration::Const::Builder Declaration::Builder::initConst() {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::CONST);
+ _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS).clear();
+ _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Const::Builder(_builder);
+}
+inline bool Declaration::Reader::isEnum() const {
+ return which() == Declaration::ENUM;
+}
+inline bool Declaration::Builder::isEnum() {
+ return which() == Declaration::ENUM;
+}
+inline ::capnp::Void Declaration::Reader::getEnum() const {
+ KJ_IREQUIRE((which() == Declaration::ENUM),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getEnum() {
+ KJ_IREQUIRE((which() == Declaration::ENUM),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setEnum( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::ENUM);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isEnumerant() const {
+ return which() == Declaration::ENUMERANT;
+}
+inline bool Declaration::Builder::isEnumerant() {
+ return which() == Declaration::ENUMERANT;
+}
+inline ::capnp::Void Declaration::Reader::getEnumerant() const {
+ KJ_IREQUIRE((which() == Declaration::ENUMERANT),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getEnumerant() {
+ KJ_IREQUIRE((which() == Declaration::ENUMERANT),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setEnumerant( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::ENUMERANT);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isStruct() const {
+ return which() == Declaration::STRUCT;
+}
+inline bool Declaration::Builder::isStruct() {
+ return which() == Declaration::STRUCT;
+}
+inline ::capnp::Void Declaration::Reader::getStruct() const {
+ KJ_IREQUIRE((which() == Declaration::STRUCT),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getStruct() {
+ KJ_IREQUIRE((which() == Declaration::STRUCT),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setStruct( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::STRUCT);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isField() const {
+ return which() == Declaration::FIELD;
+}
+inline bool Declaration::Builder::isField() {
+ return which() == Declaration::FIELD;
+}
+inline typename Declaration::Field::Reader Declaration::Reader::getField() const {
+ KJ_IREQUIRE((which() == Declaration::FIELD),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Field::Reader(_reader);
+}
+inline typename Declaration::Field::Builder Declaration::Builder::getField() {
+ KJ_IREQUIRE((which() == Declaration::FIELD),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Field::Builder(_builder);
+}
+inline typename Declaration::Field::Builder Declaration::Builder::initField() {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::FIELD);
+ _builder.setDataField< ::uint16_t>(::capnp::bounded<6>() * ::capnp::ELEMENTS, 0);
+ _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS).clear();
+ _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Field::Builder(_builder);
+}
+inline bool Declaration::Reader::isUnion() const {
+ return which() == Declaration::UNION;
+}
+inline bool Declaration::Builder::isUnion() {
+ return which() == Declaration::UNION;
+}
+inline ::capnp::Void Declaration::Reader::getUnion() const {
+ KJ_IREQUIRE((which() == Declaration::UNION),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getUnion() {
+ KJ_IREQUIRE((which() == Declaration::UNION),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setUnion( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::UNION);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isGroup() const {
+ return which() == Declaration::GROUP;
+}
+inline bool Declaration::Builder::isGroup() {
+ return which() == Declaration::GROUP;
+}
+inline ::capnp::Void Declaration::Reader::getGroup() const {
+ KJ_IREQUIRE((which() == Declaration::GROUP),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getGroup() {
+ KJ_IREQUIRE((which() == Declaration::GROUP),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setGroup( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::GROUP);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isInterface() const {
+ return which() == Declaration::INTERFACE;
+}
+inline bool Declaration::Builder::isInterface() {
+ return which() == Declaration::INTERFACE;
+}
+inline typename Declaration::Interface::Reader Declaration::Reader::getInterface() const {
+ KJ_IREQUIRE((which() == Declaration::INTERFACE),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Interface::Reader(_reader);
+}
+inline typename Declaration::Interface::Builder Declaration::Builder::getInterface() {
+ KJ_IREQUIRE((which() == Declaration::INTERFACE),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Interface::Builder(_builder);
+}
+inline typename Declaration::Interface::Builder Declaration::Builder::initInterface() {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::INTERFACE);
+ _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Interface::Builder(_builder);
+}
+inline bool Declaration::Reader::isMethod() const {
+ return which() == Declaration::METHOD;
+}
+inline bool Declaration::Builder::isMethod() {
+ return which() == Declaration::METHOD;
+}
+inline typename Declaration::Method::Reader Declaration::Reader::getMethod() const {
+ KJ_IREQUIRE((which() == Declaration::METHOD),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Method::Reader(_reader);
+}
+inline typename Declaration::Method::Builder Declaration::Builder::getMethod() {
+ KJ_IREQUIRE((which() == Declaration::METHOD),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Method::Builder(_builder);
+}
+inline typename Declaration::Method::Builder Declaration::Builder::initMethod() {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::METHOD);
+ _builder.setDataField< ::uint16_t>(::capnp::bounded<6>() * ::capnp::ELEMENTS, 0);
+ _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS).clear();
+ _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Method::Builder(_builder);
+}
+inline bool Declaration::Reader::isAnnotation() const {
+ return which() == Declaration::ANNOTATION;
+}
+inline bool Declaration::Builder::isAnnotation() {
+ return which() == Declaration::ANNOTATION;
+}
+inline typename Declaration::Annotation::Reader Declaration::Reader::getAnnotation() const {
+ KJ_IREQUIRE((which() == Declaration::ANNOTATION),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Annotation::Reader(_reader);
+}
+inline typename Declaration::Annotation::Builder Declaration::Builder::getAnnotation() {
+ KJ_IREQUIRE((which() == Declaration::ANNOTATION),
+ "Must check which() before get()ing a union member.");
+ return typename Declaration::Annotation::Builder(_builder);
+}
+inline typename Declaration::Annotation::Builder Declaration::Builder::initAnnotation() {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::ANNOTATION);
+ _builder.setDataField<bool>(::capnp::bounded<96>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<97>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<98>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<99>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<100>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<101>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<102>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<103>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<104>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<105>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<106>() * ::capnp::ELEMENTS, 0);
+ _builder.setDataField<bool>(::capnp::bounded<107>() * ::capnp::ELEMENTS, 0);
+ _builder.getPointerField(::capnp::bounded<5>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Annotation::Builder(_builder);
+}
+inline bool Declaration::Reader::isNakedId() const {
+ return which() == Declaration::NAKED_ID;
+}
+inline bool Declaration::Builder::isNakedId() {
+ return which() == Declaration::NAKED_ID;
+}
+inline bool Declaration::Reader::hasNakedId() const {
+ if (which() != Declaration::NAKED_ID) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Builder::hasNakedId() {
+ if (which() != Declaration::NAKED_ID) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedInteger::Reader Declaration::Reader::getNakedId() const {
+ KJ_IREQUIRE((which() == Declaration::NAKED_ID),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::get(_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedInteger::Builder Declaration::Builder::getNakedId() {
+ KJ_IREQUIRE((which() == Declaration::NAKED_ID),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::get(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::setNakedId( ::capnp::compiler::LocatedInteger::Reader value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::NAKED_ID);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::set(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedInteger::Builder Declaration::Builder::initNakedId() {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::NAKED_ID);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::init(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::adoptNakedId(
+ ::capnp::Orphan< ::capnp::compiler::LocatedInteger>&& value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::NAKED_ID);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::adopt(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedInteger> Declaration::Builder::disownNakedId() {
+ KJ_IREQUIRE((which() == Declaration::NAKED_ID),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::disown(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Reader::isNakedAnnotation() const {
+ return which() == Declaration::NAKED_ANNOTATION;
+}
+inline bool Declaration::Builder::isNakedAnnotation() {
+ return which() == Declaration::NAKED_ANNOTATION;
+}
+inline bool Declaration::Reader::hasNakedAnnotation() const {
+ if (which() != Declaration::NAKED_ANNOTATION) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Builder::hasNakedAnnotation() {
+ if (which() != Declaration::NAKED_ANNOTATION) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Declaration::AnnotationApplication::Reader Declaration::Reader::getNakedAnnotation() const {
+ KJ_IREQUIRE((which() == Declaration::NAKED_ANNOTATION),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::AnnotationApplication>::get(_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Declaration::AnnotationApplication::Builder Declaration::Builder::getNakedAnnotation() {
+ KJ_IREQUIRE((which() == Declaration::NAKED_ANNOTATION),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::AnnotationApplication>::get(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::setNakedAnnotation( ::capnp::compiler::Declaration::AnnotationApplication::Reader value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::NAKED_ANNOTATION);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::AnnotationApplication>::set(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Declaration::AnnotationApplication::Builder Declaration::Builder::initNakedAnnotation() {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::NAKED_ANNOTATION);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::AnnotationApplication>::init(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::adoptNakedAnnotation(
+ ::capnp::Orphan< ::capnp::compiler::Declaration::AnnotationApplication>&& value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::NAKED_ANNOTATION);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::AnnotationApplication>::adopt(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Declaration::AnnotationApplication> Declaration::Builder::disownNakedAnnotation() {
+ KJ_IREQUIRE((which() == Declaration::NAKED_ANNOTATION),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::AnnotationApplication>::disown(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Reader::isBuiltinVoid() const {
+ return which() == Declaration::BUILTIN_VOID;
+}
+inline bool Declaration::Builder::isBuiltinVoid() {
+ return which() == Declaration::BUILTIN_VOID;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinVoid() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_VOID),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinVoid() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_VOID),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinVoid( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_VOID);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinBool() const {
+ return which() == Declaration::BUILTIN_BOOL;
+}
+inline bool Declaration::Builder::isBuiltinBool() {
+ return which() == Declaration::BUILTIN_BOOL;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinBool() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_BOOL),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinBool() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_BOOL),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinBool( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_BOOL);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinInt8() const {
+ return which() == Declaration::BUILTIN_INT8;
+}
+inline bool Declaration::Builder::isBuiltinInt8() {
+ return which() == Declaration::BUILTIN_INT8;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinInt8() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_INT8),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinInt8() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_INT8),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinInt8( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_INT8);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinInt16() const {
+ return which() == Declaration::BUILTIN_INT16;
+}
+inline bool Declaration::Builder::isBuiltinInt16() {
+ return which() == Declaration::BUILTIN_INT16;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinInt16() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_INT16),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinInt16() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_INT16),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinInt16( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_INT16);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinInt32() const {
+ return which() == Declaration::BUILTIN_INT32;
+}
+inline bool Declaration::Builder::isBuiltinInt32() {
+ return which() == Declaration::BUILTIN_INT32;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinInt32() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_INT32),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinInt32() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_INT32),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinInt32( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_INT32);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinInt64() const {
+ return which() == Declaration::BUILTIN_INT64;
+}
+inline bool Declaration::Builder::isBuiltinInt64() {
+ return which() == Declaration::BUILTIN_INT64;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinInt64() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_INT64),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinInt64() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_INT64),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinInt64( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_INT64);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinUInt8() const {
+ return which() == Declaration::BUILTIN_U_INT8;
+}
+inline bool Declaration::Builder::isBuiltinUInt8() {
+ return which() == Declaration::BUILTIN_U_INT8;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinUInt8() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_U_INT8),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinUInt8() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_U_INT8),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinUInt8( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_U_INT8);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinUInt16() const {
+ return which() == Declaration::BUILTIN_U_INT16;
+}
+inline bool Declaration::Builder::isBuiltinUInt16() {
+ return which() == Declaration::BUILTIN_U_INT16;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinUInt16() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_U_INT16),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinUInt16() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_U_INT16),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinUInt16( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_U_INT16);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinUInt32() const {
+ return which() == Declaration::BUILTIN_U_INT32;
+}
+inline bool Declaration::Builder::isBuiltinUInt32() {
+ return which() == Declaration::BUILTIN_U_INT32;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinUInt32() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_U_INT32),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinUInt32() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_U_INT32),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinUInt32( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_U_INT32);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinUInt64() const {
+ return which() == Declaration::BUILTIN_U_INT64;
+}
+inline bool Declaration::Builder::isBuiltinUInt64() {
+ return which() == Declaration::BUILTIN_U_INT64;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinUInt64() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_U_INT64),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinUInt64() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_U_INT64),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinUInt64( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_U_INT64);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinFloat32() const {
+ return which() == Declaration::BUILTIN_FLOAT32;
+}
+inline bool Declaration::Builder::isBuiltinFloat32() {
+ return which() == Declaration::BUILTIN_FLOAT32;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinFloat32() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_FLOAT32),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinFloat32() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_FLOAT32),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinFloat32( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_FLOAT32);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinFloat64() const {
+ return which() == Declaration::BUILTIN_FLOAT64;
+}
+inline bool Declaration::Builder::isBuiltinFloat64() {
+ return which() == Declaration::BUILTIN_FLOAT64;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinFloat64() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_FLOAT64),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinFloat64() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_FLOAT64),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinFloat64( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_FLOAT64);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinText() const {
+ return which() == Declaration::BUILTIN_TEXT;
+}
+inline bool Declaration::Builder::isBuiltinText() {
+ return which() == Declaration::BUILTIN_TEXT;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinText() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_TEXT),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinText() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_TEXT),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinText( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_TEXT);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinData() const {
+ return which() == Declaration::BUILTIN_DATA;
+}
+inline bool Declaration::Builder::isBuiltinData() {
+ return which() == Declaration::BUILTIN_DATA;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinData() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_DATA),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinData() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_DATA),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinData( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_DATA);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinList() const {
+ return which() == Declaration::BUILTIN_LIST;
+}
+inline bool Declaration::Builder::isBuiltinList() {
+ return which() == Declaration::BUILTIN_LIST;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinList() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_LIST),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinList() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_LIST),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinList( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_LIST);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinObject() const {
+ return which() == Declaration::BUILTIN_OBJECT;
+}
+inline bool Declaration::Builder::isBuiltinObject() {
+ return which() == Declaration::BUILTIN_OBJECT;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinObject() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_OBJECT),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinObject() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_OBJECT),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinObject( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_OBJECT);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinAnyPointer() const {
+ return which() == Declaration::BUILTIN_ANY_POINTER;
+}
+inline bool Declaration::Builder::isBuiltinAnyPointer() {
+ return which() == Declaration::BUILTIN_ANY_POINTER;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinAnyPointer() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_ANY_POINTER),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinAnyPointer() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_ANY_POINTER),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinAnyPointer( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_ANY_POINTER);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::hasParameters() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Builder::hasParameters() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<7>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>::Reader Declaration::Reader::getParameters() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>>::get(_reader.getPointerField(
+ ::capnp::bounded<7>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>::Builder Declaration::Builder::getParameters() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>>::get(_builder.getPointerField(
+ ::capnp::bounded<7>() * ::capnp::POINTERS));
+}
+inline void Declaration::Builder::setParameters( ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>>::set(_builder.getPointerField(
+ ::capnp::bounded<7>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>::Builder Declaration::Builder::initParameters(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>>::init(_builder.getPointerField(
+ ::capnp::bounded<7>() * ::capnp::POINTERS), size);
+}
+inline void Declaration::Builder::adoptParameters(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<7>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>> Declaration::Builder::disownParameters() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::BrandParameter>>::disown(_builder.getPointerField(
+ ::capnp::bounded<7>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Reader::isBuiltinAnyStruct() const {
+ return which() == Declaration::BUILTIN_ANY_STRUCT;
+}
+inline bool Declaration::Builder::isBuiltinAnyStruct() {
+ return which() == Declaration::BUILTIN_ANY_STRUCT;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinAnyStruct() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_ANY_STRUCT),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinAnyStruct() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_ANY_STRUCT),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinAnyStruct( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_ANY_STRUCT);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinAnyList() const {
+ return which() == Declaration::BUILTIN_ANY_LIST;
+}
+inline bool Declaration::Builder::isBuiltinAnyList() {
+ return which() == Declaration::BUILTIN_ANY_LIST;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinAnyList() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_ANY_LIST),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinAnyList() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_ANY_LIST),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinAnyList( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_ANY_LIST);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Reader::isBuiltinCapability() const {
+ return which() == Declaration::BUILTIN_CAPABILITY;
+}
+inline bool Declaration::Builder::isBuiltinCapability() {
+ return which() == Declaration::BUILTIN_CAPABILITY;
+}
+inline ::capnp::Void Declaration::Reader::getBuiltinCapability() const {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_CAPABILITY),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Builder::getBuiltinCapability() {
+ KJ_IREQUIRE((which() == Declaration::BUILTIN_CAPABILITY),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Builder::setBuiltinCapability( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Which>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, Declaration::BUILTIN_CAPABILITY);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::BrandParameter::Reader::hasName() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::BrandParameter::Builder::hasName() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Text::Reader Declaration::BrandParameter::Reader::getName() const {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::Text::Builder Declaration::BrandParameter::Builder::getName() {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Declaration::BrandParameter::Builder::setName( ::capnp::Text::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Text::Builder Declaration::BrandParameter::Builder::initName(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Declaration::BrandParameter::Builder::adoptName(
+ ::capnp::Orphan< ::capnp::Text>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Text> Declaration::BrandParameter::Builder::disownName() {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline ::uint32_t Declaration::BrandParameter::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Declaration::BrandParameter::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::BrandParameter::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t Declaration::BrandParameter::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Declaration::BrandParameter::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::BrandParameter::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::AnnotationApplication::Reader::hasName() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::AnnotationApplication::Builder::hasName() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::AnnotationApplication::Reader::getName() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::AnnotationApplication::Builder::getName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Declaration::AnnotationApplication::Pipeline::getName() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(0));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::AnnotationApplication::Builder::setName( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::AnnotationApplication::Builder::initName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Declaration::AnnotationApplication::Builder::adoptName(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::AnnotationApplication::Builder::disownName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline typename Declaration::AnnotationApplication::Value::Reader Declaration::AnnotationApplication::Reader::getValue() const {
+ return typename Declaration::AnnotationApplication::Value::Reader(_reader);
+}
+inline typename Declaration::AnnotationApplication::Value::Builder Declaration::AnnotationApplication::Builder::getValue() {
+ return typename Declaration::AnnotationApplication::Value::Builder(_builder);
+}
+#if !CAPNP_LITE
+inline typename Declaration::AnnotationApplication::Value::Pipeline Declaration::AnnotationApplication::Pipeline::getValue() {
+ return typename Declaration::AnnotationApplication::Value::Pipeline(_typeless.noop());
+}
+#endif // !CAPNP_LITE
+inline typename Declaration::AnnotationApplication::Value::Builder Declaration::AnnotationApplication::Builder::initValue() {
+ _builder.setDataField< ::uint16_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0);
+ _builder.getPointerField(::capnp::bounded<1>() * ::capnp::POINTERS).clear();
+ return typename Declaration::AnnotationApplication::Value::Builder(_builder);
+}
+inline ::capnp::compiler::Declaration::AnnotationApplication::Value::Which Declaration::AnnotationApplication::Value::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Declaration::AnnotationApplication::Value::Which Declaration::AnnotationApplication::Value::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::AnnotationApplication::Value::Reader::isNone() const {
+ return which() == Declaration::AnnotationApplication::Value::NONE;
+}
+inline bool Declaration::AnnotationApplication::Value::Builder::isNone() {
+ return which() == Declaration::AnnotationApplication::Value::NONE;
+}
+inline ::capnp::Void Declaration::AnnotationApplication::Value::Reader::getNone() const {
+ KJ_IREQUIRE((which() == Declaration::AnnotationApplication::Value::NONE),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::AnnotationApplication::Value::Builder::getNone() {
+ KJ_IREQUIRE((which() == Declaration::AnnotationApplication::Value::NONE),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::AnnotationApplication::Value::Builder::setNone( ::capnp::Void value) {
+ _builder.setDataField<Declaration::AnnotationApplication::Value::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::AnnotationApplication::Value::NONE);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::AnnotationApplication::Value::Reader::isExpression() const {
+ return which() == Declaration::AnnotationApplication::Value::EXPRESSION;
+}
+inline bool Declaration::AnnotationApplication::Value::Builder::isExpression() {
+ return which() == Declaration::AnnotationApplication::Value::EXPRESSION;
+}
+inline bool Declaration::AnnotationApplication::Value::Reader::hasExpression() const {
+ if (which() != Declaration::AnnotationApplication::Value::EXPRESSION) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::AnnotationApplication::Value::Builder::hasExpression() {
+ if (which() != Declaration::AnnotationApplication::Value::EXPRESSION) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::AnnotationApplication::Value::Reader::getExpression() const {
+ KJ_IREQUIRE((which() == Declaration::AnnotationApplication::Value::EXPRESSION),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::AnnotationApplication::Value::Builder::getExpression() {
+ KJ_IREQUIRE((which() == Declaration::AnnotationApplication::Value::EXPRESSION),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Declaration::AnnotationApplication::Value::Builder::setExpression( ::capnp::compiler::Expression::Reader value) {
+ _builder.setDataField<Declaration::AnnotationApplication::Value::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::AnnotationApplication::Value::EXPRESSION);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::AnnotationApplication::Value::Builder::initExpression() {
+ _builder.setDataField<Declaration::AnnotationApplication::Value::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::AnnotationApplication::Value::EXPRESSION);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Declaration::AnnotationApplication::Value::Builder::adoptExpression(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ _builder.setDataField<Declaration::AnnotationApplication::Value::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::AnnotationApplication::Value::EXPRESSION);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::AnnotationApplication::Value::Builder::disownExpression() {
+ KJ_IREQUIRE((which() == Declaration::AnnotationApplication::Value::EXPRESSION),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+
+inline ::capnp::compiler::Declaration::ParamList::Which Declaration::ParamList::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Declaration::ParamList::Which Declaration::ParamList::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::ParamList::Reader::isNamedList() const {
+ return which() == Declaration::ParamList::NAMED_LIST;
+}
+inline bool Declaration::ParamList::Builder::isNamedList() {
+ return which() == Declaration::ParamList::NAMED_LIST;
+}
+inline bool Declaration::ParamList::Reader::hasNamedList() const {
+ if (which() != Declaration::ParamList::NAMED_LIST) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::ParamList::Builder::hasNamedList() {
+ if (which() != Declaration::ParamList::NAMED_LIST) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::Param>::Reader Declaration::ParamList::Reader::getNamedList() const {
+ KJ_IREQUIRE((which() == Declaration::ParamList::NAMED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::Param>>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::Param>::Builder Declaration::ParamList::Builder::getNamedList() {
+ KJ_IREQUIRE((which() == Declaration::ParamList::NAMED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::Param>>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Declaration::ParamList::Builder::setNamedList( ::capnp::List< ::capnp::compiler::Declaration::Param>::Reader value) {
+ _builder.setDataField<Declaration::ParamList::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::ParamList::NAMED_LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::Param>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::Param>::Builder Declaration::ParamList::Builder::initNamedList(unsigned int size) {
+ _builder.setDataField<Declaration::ParamList::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::ParamList::NAMED_LIST);
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::Param>>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Declaration::ParamList::Builder::adoptNamedList(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::Param>>&& value) {
+ _builder.setDataField<Declaration::ParamList::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::ParamList::NAMED_LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::Param>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::Param>> Declaration::ParamList::Builder::disownNamedList() {
+ KJ_IREQUIRE((which() == Declaration::ParamList::NAMED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::Param>>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::ParamList::Reader::isType() const {
+ return which() == Declaration::ParamList::TYPE;
+}
+inline bool Declaration::ParamList::Builder::isType() {
+ return which() == Declaration::ParamList::TYPE;
+}
+inline bool Declaration::ParamList::Reader::hasType() const {
+ if (which() != Declaration::ParamList::TYPE) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::ParamList::Builder::hasType() {
+ if (which() != Declaration::ParamList::TYPE) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::ParamList::Reader::getType() const {
+ KJ_IREQUIRE((which() == Declaration::ParamList::TYPE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::ParamList::Builder::getType() {
+ KJ_IREQUIRE((which() == Declaration::ParamList::TYPE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Declaration::ParamList::Builder::setType( ::capnp::compiler::Expression::Reader value) {
+ _builder.setDataField<Declaration::ParamList::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::ParamList::TYPE);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::ParamList::Builder::initType() {
+ _builder.setDataField<Declaration::ParamList::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::ParamList::TYPE);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Declaration::ParamList::Builder::adoptType(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ _builder.setDataField<Declaration::ParamList::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::ParamList::TYPE);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::ParamList::Builder::disownType() {
+ KJ_IREQUIRE((which() == Declaration::ParamList::TYPE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline ::uint32_t Declaration::ParamList::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Declaration::ParamList::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::ParamList::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t Declaration::ParamList::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Declaration::ParamList::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::ParamList::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Param::Reader::hasName() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Param::Builder::hasName() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedText::Reader Declaration::Param::Reader::getName() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedText::Builder Declaration::Param::Builder::getName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::LocatedText::Pipeline Declaration::Param::Pipeline::getName() {
+ return ::capnp::compiler::LocatedText::Pipeline(_typeless.getPointerField(0));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Param::Builder::setName( ::capnp::compiler::LocatedText::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedText::Builder Declaration::Param::Builder::initName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Declaration::Param::Builder::adoptName(
+ ::capnp::Orphan< ::capnp::compiler::LocatedText>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedText> Declaration::Param::Builder::disownName() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedText>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Param::Reader::hasType() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Param::Builder::hasType() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::Param::Reader::getType() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Param::Builder::getType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Declaration::Param::Pipeline::getType() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(1));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Param::Builder::setType( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Param::Builder::initType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Declaration::Param::Builder::adoptType(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::Param::Builder::disownType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Param::Reader::hasAnnotations() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Param::Builder::hasAnnotations() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Reader Declaration::Param::Reader::getAnnotations() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::get(_reader.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Builder Declaration::Param::Builder::getAnnotations() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::get(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+inline void Declaration::Param::Builder::setAnnotations( ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::set(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>::Builder Declaration::Param::Builder::initAnnotations(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::init(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), size);
+}
+inline void Declaration::Param::Builder::adoptAnnotations(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>> Declaration::Param::Builder::disownAnnotations() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Declaration::AnnotationApplication>>::disown(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+
+inline typename Declaration::Param::DefaultValue::Reader Declaration::Param::Reader::getDefaultValue() const {
+ return typename Declaration::Param::DefaultValue::Reader(_reader);
+}
+inline typename Declaration::Param::DefaultValue::Builder Declaration::Param::Builder::getDefaultValue() {
+ return typename Declaration::Param::DefaultValue::Builder(_builder);
+}
+#if !CAPNP_LITE
+inline typename Declaration::Param::DefaultValue::Pipeline Declaration::Param::Pipeline::getDefaultValue() {
+ return typename Declaration::Param::DefaultValue::Pipeline(_typeless.noop());
+}
+#endif // !CAPNP_LITE
+inline typename Declaration::Param::DefaultValue::Builder Declaration::Param::Builder::initDefaultValue() {
+ _builder.setDataField< ::uint16_t>(::capnp::bounded<0>() * ::capnp::ELEMENTS, 0);
+ _builder.getPointerField(::capnp::bounded<3>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Param::DefaultValue::Builder(_builder);
+}
+inline ::uint32_t Declaration::Param::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Declaration::Param::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Param::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t Declaration::Param::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Declaration::Param::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Param::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::capnp::compiler::Declaration::Param::DefaultValue::Which Declaration::Param::DefaultValue::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Declaration::Param::DefaultValue::Which Declaration::Param::DefaultValue::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Param::DefaultValue::Reader::isNone() const {
+ return which() == Declaration::Param::DefaultValue::NONE;
+}
+inline bool Declaration::Param::DefaultValue::Builder::isNone() {
+ return which() == Declaration::Param::DefaultValue::NONE;
+}
+inline ::capnp::Void Declaration::Param::DefaultValue::Reader::getNone() const {
+ KJ_IREQUIRE((which() == Declaration::Param::DefaultValue::NONE),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Param::DefaultValue::Builder::getNone() {
+ KJ_IREQUIRE((which() == Declaration::Param::DefaultValue::NONE),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Param::DefaultValue::Builder::setNone( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Param::DefaultValue::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Param::DefaultValue::NONE);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Param::DefaultValue::Reader::isValue() const {
+ return which() == Declaration::Param::DefaultValue::VALUE;
+}
+inline bool Declaration::Param::DefaultValue::Builder::isValue() {
+ return which() == Declaration::Param::DefaultValue::VALUE;
+}
+inline bool Declaration::Param::DefaultValue::Reader::hasValue() const {
+ if (which() != Declaration::Param::DefaultValue::VALUE) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Param::DefaultValue::Builder::hasValue() {
+ if (which() != Declaration::Param::DefaultValue::VALUE) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::Param::DefaultValue::Reader::getValue() const {
+ KJ_IREQUIRE((which() == Declaration::Param::DefaultValue::VALUE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Param::DefaultValue::Builder::getValue() {
+ KJ_IREQUIRE((which() == Declaration::Param::DefaultValue::VALUE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS));
+}
+inline void Declaration::Param::DefaultValue::Builder::setValue( ::capnp::compiler::Expression::Reader value) {
+ _builder.setDataField<Declaration::Param::DefaultValue::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Param::DefaultValue::VALUE);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Param::DefaultValue::Builder::initValue() {
+ _builder.setDataField<Declaration::Param::DefaultValue::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Param::DefaultValue::VALUE);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS));
+}
+inline void Declaration::Param::DefaultValue::Builder::adoptValue(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ _builder.setDataField<Declaration::Param::DefaultValue::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Param::DefaultValue::VALUE);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::Param::DefaultValue::Builder::disownValue() {
+ KJ_IREQUIRE((which() == Declaration::Param::DefaultValue::VALUE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<3>() * ::capnp::POINTERS));
+}
+
+inline ::capnp::compiler::Declaration::Id::Which Declaration::Id::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Declaration::Id::Which Declaration::Id::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Id::Reader::isUnspecified() const {
+ return which() == Declaration::Id::UNSPECIFIED;
+}
+inline bool Declaration::Id::Builder::isUnspecified() {
+ return which() == Declaration::Id::UNSPECIFIED;
+}
+inline ::capnp::Void Declaration::Id::Reader::getUnspecified() const {
+ KJ_IREQUIRE((which() == Declaration::Id::UNSPECIFIED),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Id::Builder::getUnspecified() {
+ KJ_IREQUIRE((which() == Declaration::Id::UNSPECIFIED),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Id::Builder::setUnspecified( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Id::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Id::UNSPECIFIED);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Id::Reader::isUid() const {
+ return which() == Declaration::Id::UID;
+}
+inline bool Declaration::Id::Builder::isUid() {
+ return which() == Declaration::Id::UID;
+}
+inline bool Declaration::Id::Reader::hasUid() const {
+ if (which() != Declaration::Id::UID) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Id::Builder::hasUid() {
+ if (which() != Declaration::Id::UID) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedInteger::Reader Declaration::Id::Reader::getUid() const {
+ KJ_IREQUIRE((which() == Declaration::Id::UID),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::get(_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedInteger::Builder Declaration::Id::Builder::getUid() {
+ KJ_IREQUIRE((which() == Declaration::Id::UID),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::get(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Declaration::Id::Builder::setUid( ::capnp::compiler::LocatedInteger::Reader value) {
+ _builder.setDataField<Declaration::Id::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Id::UID);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::set(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedInteger::Builder Declaration::Id::Builder::initUid() {
+ _builder.setDataField<Declaration::Id::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Id::UID);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::init(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Declaration::Id::Builder::adoptUid(
+ ::capnp::Orphan< ::capnp::compiler::LocatedInteger>&& value) {
+ _builder.setDataField<Declaration::Id::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Id::UID);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::adopt(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedInteger> Declaration::Id::Builder::disownUid() {
+ KJ_IREQUIRE((which() == Declaration::Id::UID),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::disown(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Id::Reader::isOrdinal() const {
+ return which() == Declaration::Id::ORDINAL;
+}
+inline bool Declaration::Id::Builder::isOrdinal() {
+ return which() == Declaration::Id::ORDINAL;
+}
+inline bool Declaration::Id::Reader::hasOrdinal() const {
+ if (which() != Declaration::Id::ORDINAL) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Id::Builder::hasOrdinal() {
+ if (which() != Declaration::Id::ORDINAL) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::LocatedInteger::Reader Declaration::Id::Reader::getOrdinal() const {
+ KJ_IREQUIRE((which() == Declaration::Id::ORDINAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::get(_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::LocatedInteger::Builder Declaration::Id::Builder::getOrdinal() {
+ KJ_IREQUIRE((which() == Declaration::Id::ORDINAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::get(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Declaration::Id::Builder::setOrdinal( ::capnp::compiler::LocatedInteger::Reader value) {
+ _builder.setDataField<Declaration::Id::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Id::ORDINAL);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::set(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::LocatedInteger::Builder Declaration::Id::Builder::initOrdinal() {
+ _builder.setDataField<Declaration::Id::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Id::ORDINAL);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::init(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Declaration::Id::Builder::adoptOrdinal(
+ ::capnp::Orphan< ::capnp::compiler::LocatedInteger>&& value) {
+ _builder.setDataField<Declaration::Id::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Declaration::Id::ORDINAL);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::adopt(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::LocatedInteger> Declaration::Id::Builder::disownOrdinal() {
+ KJ_IREQUIRE((which() == Declaration::Id::ORDINAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::LocatedInteger>::disown(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Using::Reader::hasTarget() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Using::Builder::hasTarget() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::Using::Reader::getTarget() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Using::Builder::getTarget() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Declaration::Using::Pipeline::getTarget() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(5));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Using::Builder::setTarget( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Using::Builder::initTarget() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Using::Builder::adoptTarget(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::Using::Builder::disownTarget() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Const::Reader::hasType() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Const::Builder::hasType() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::Const::Reader::getType() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Const::Builder::getType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Declaration::Const::Pipeline::getType() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(5));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Const::Builder::setType( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Const::Builder::initType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Const::Builder::adoptType(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::Const::Builder::disownType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Const::Reader::hasValue() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Const::Builder::hasValue() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::Const::Reader::getValue() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Const::Builder::getValue() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Declaration::Const::Pipeline::getValue() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(6));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Const::Builder::setValue( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Const::Builder::initValue() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+inline void Declaration::Const::Builder::adoptValue(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::Const::Builder::disownValue() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Field::Reader::hasType() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Field::Builder::hasType() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::Field::Reader::getType() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Field::Builder::getType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Declaration::Field::Pipeline::getType() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(5));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Field::Builder::setType( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Field::Builder::initType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Field::Builder::adoptType(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::Field::Builder::disownType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+
+inline typename Declaration::Field::DefaultValue::Reader Declaration::Field::Reader::getDefaultValue() const {
+ return typename Declaration::Field::DefaultValue::Reader(_reader);
+}
+inline typename Declaration::Field::DefaultValue::Builder Declaration::Field::Builder::getDefaultValue() {
+ return typename Declaration::Field::DefaultValue::Builder(_builder);
+}
+#if !CAPNP_LITE
+inline typename Declaration::Field::DefaultValue::Pipeline Declaration::Field::Pipeline::getDefaultValue() {
+ return typename Declaration::Field::DefaultValue::Pipeline(_typeless.noop());
+}
+#endif // !CAPNP_LITE
+inline typename Declaration::Field::DefaultValue::Builder Declaration::Field::Builder::initDefaultValue() {
+ _builder.setDataField< ::uint16_t>(::capnp::bounded<6>() * ::capnp::ELEMENTS, 0);
+ _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Field::DefaultValue::Builder(_builder);
+}
+inline ::capnp::compiler::Declaration::Field::DefaultValue::Which Declaration::Field::DefaultValue::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Declaration::Field::DefaultValue::Which Declaration::Field::DefaultValue::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Field::DefaultValue::Reader::isNone() const {
+ return which() == Declaration::Field::DefaultValue::NONE;
+}
+inline bool Declaration::Field::DefaultValue::Builder::isNone() {
+ return which() == Declaration::Field::DefaultValue::NONE;
+}
+inline ::capnp::Void Declaration::Field::DefaultValue::Reader::getNone() const {
+ KJ_IREQUIRE((which() == Declaration::Field::DefaultValue::NONE),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Field::DefaultValue::Builder::getNone() {
+ KJ_IREQUIRE((which() == Declaration::Field::DefaultValue::NONE),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Field::DefaultValue::Builder::setNone( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Field::DefaultValue::Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS, Declaration::Field::DefaultValue::NONE);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Field::DefaultValue::Reader::isValue() const {
+ return which() == Declaration::Field::DefaultValue::VALUE;
+}
+inline bool Declaration::Field::DefaultValue::Builder::isValue() {
+ return which() == Declaration::Field::DefaultValue::VALUE;
+}
+inline bool Declaration::Field::DefaultValue::Reader::hasValue() const {
+ if (which() != Declaration::Field::DefaultValue::VALUE) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Field::DefaultValue::Builder::hasValue() {
+ if (which() != Declaration::Field::DefaultValue::VALUE) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::Field::DefaultValue::Reader::getValue() const {
+ KJ_IREQUIRE((which() == Declaration::Field::DefaultValue::VALUE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Field::DefaultValue::Builder::getValue() {
+ KJ_IREQUIRE((which() == Declaration::Field::DefaultValue::VALUE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+inline void Declaration::Field::DefaultValue::Builder::setValue( ::capnp::compiler::Expression::Reader value) {
+ _builder.setDataField<Declaration::Field::DefaultValue::Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS, Declaration::Field::DefaultValue::VALUE);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Field::DefaultValue::Builder::initValue() {
+ _builder.setDataField<Declaration::Field::DefaultValue::Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS, Declaration::Field::DefaultValue::VALUE);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+inline void Declaration::Field::DefaultValue::Builder::adoptValue(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ _builder.setDataField<Declaration::Field::DefaultValue::Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS, Declaration::Field::DefaultValue::VALUE);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::Field::DefaultValue::Builder::disownValue() {
+ KJ_IREQUIRE((which() == Declaration::Field::DefaultValue::VALUE),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Interface::Reader::hasSuperclasses() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Interface::Builder::hasSuperclasses() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Expression>::Reader Declaration::Interface::Reader::getSuperclasses() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::get(_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Expression>::Builder Declaration::Interface::Builder::getSuperclasses() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::get(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Interface::Builder::setSuperclasses( ::capnp::List< ::capnp::compiler::Expression>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::set(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Expression>::Builder Declaration::Interface::Builder::initSuperclasses(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::init(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), size);
+}
+inline void Declaration::Interface::Builder::adoptSuperclasses(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Expression>> Declaration::Interface::Builder::disownSuperclasses() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Expression>>::disown(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Method::Reader::hasParams() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Method::Builder::hasParams() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Declaration::ParamList::Reader Declaration::Method::Reader::getParams() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::get(_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Declaration::ParamList::Builder Declaration::Method::Builder::getParams() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::get(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Declaration::ParamList::Pipeline Declaration::Method::Pipeline::getParams() {
+ return ::capnp::compiler::Declaration::ParamList::Pipeline(_typeless.getPointerField(5));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Method::Builder::setParams( ::capnp::compiler::Declaration::ParamList::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::set(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Declaration::ParamList::Builder Declaration::Method::Builder::initParams() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::init(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Method::Builder::adoptParams(
+ ::capnp::Orphan< ::capnp::compiler::Declaration::ParamList>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::adopt(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Declaration::ParamList> Declaration::Method::Builder::disownParams() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::disown(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+
+inline typename Declaration::Method::Results::Reader Declaration::Method::Reader::getResults() const {
+ return typename Declaration::Method::Results::Reader(_reader);
+}
+inline typename Declaration::Method::Results::Builder Declaration::Method::Builder::getResults() {
+ return typename Declaration::Method::Results::Builder(_builder);
+}
+#if !CAPNP_LITE
+inline typename Declaration::Method::Results::Pipeline Declaration::Method::Pipeline::getResults() {
+ return typename Declaration::Method::Results::Pipeline(_typeless.noop());
+}
+#endif // !CAPNP_LITE
+inline typename Declaration::Method::Results::Builder Declaration::Method::Builder::initResults() {
+ _builder.setDataField< ::uint16_t>(::capnp::bounded<6>() * ::capnp::ELEMENTS, 0);
+ _builder.getPointerField(::capnp::bounded<6>() * ::capnp::POINTERS).clear();
+ return typename Declaration::Method::Results::Builder(_builder);
+}
+inline ::capnp::compiler::Declaration::Method::Results::Which Declaration::Method::Results::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Declaration::Method::Results::Which Declaration::Method::Results::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Method::Results::Reader::isNone() const {
+ return which() == Declaration::Method::Results::NONE;
+}
+inline bool Declaration::Method::Results::Builder::isNone() {
+ return which() == Declaration::Method::Results::NONE;
+}
+inline ::capnp::Void Declaration::Method::Results::Reader::getNone() const {
+ KJ_IREQUIRE((which() == Declaration::Method::Results::NONE),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Declaration::Method::Results::Builder::getNone() {
+ KJ_IREQUIRE((which() == Declaration::Method::Results::NONE),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Method::Results::Builder::setNone( ::capnp::Void value) {
+ _builder.setDataField<Declaration::Method::Results::Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS, Declaration::Method::Results::NONE);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Method::Results::Reader::isExplicit() const {
+ return which() == Declaration::Method::Results::EXPLICIT;
+}
+inline bool Declaration::Method::Results::Builder::isExplicit() {
+ return which() == Declaration::Method::Results::EXPLICIT;
+}
+inline bool Declaration::Method::Results::Reader::hasExplicit() const {
+ if (which() != Declaration::Method::Results::EXPLICIT) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Method::Results::Builder::hasExplicit() {
+ if (which() != Declaration::Method::Results::EXPLICIT) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Declaration::ParamList::Reader Declaration::Method::Results::Reader::getExplicit() const {
+ KJ_IREQUIRE((which() == Declaration::Method::Results::EXPLICIT),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::get(_reader.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Declaration::ParamList::Builder Declaration::Method::Results::Builder::getExplicit() {
+ KJ_IREQUIRE((which() == Declaration::Method::Results::EXPLICIT),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::get(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+inline void Declaration::Method::Results::Builder::setExplicit( ::capnp::compiler::Declaration::ParamList::Reader value) {
+ _builder.setDataField<Declaration::Method::Results::Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS, Declaration::Method::Results::EXPLICIT);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::set(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Declaration::ParamList::Builder Declaration::Method::Results::Builder::initExplicit() {
+ _builder.setDataField<Declaration::Method::Results::Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS, Declaration::Method::Results::EXPLICIT);
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::init(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+inline void Declaration::Method::Results::Builder::adoptExplicit(
+ ::capnp::Orphan< ::capnp::compiler::Declaration::ParamList>&& value) {
+ _builder.setDataField<Declaration::Method::Results::Which>(
+ ::capnp::bounded<6>() * ::capnp::ELEMENTS, Declaration::Method::Results::EXPLICIT);
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::adopt(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Declaration::ParamList> Declaration::Method::Results::Builder::disownExplicit() {
+ KJ_IREQUIRE((which() == Declaration::Method::Results::EXPLICIT),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration::ParamList>::disown(_builder.getPointerField(
+ ::capnp::bounded<6>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Annotation::Reader::hasType() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline bool Declaration::Annotation::Builder::hasType() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Expression::Reader Declaration::Annotation::Reader::getType() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_reader.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Annotation::Builder::getType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::get(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Expression::Pipeline Declaration::Annotation::Pipeline::getType() {
+ return ::capnp::compiler::Expression::Pipeline(_typeless.getPointerField(5));
+}
+#endif // !CAPNP_LITE
+inline void Declaration::Annotation::Builder::setType( ::capnp::compiler::Expression::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::set(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Expression::Builder Declaration::Annotation::Builder::initType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::init(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+inline void Declaration::Annotation::Builder::adoptType(
+ ::capnp::Orphan< ::capnp::compiler::Expression>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::adopt(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Expression> Declaration::Annotation::Builder::disownType() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Expression>::disown(_builder.getPointerField(
+ ::capnp::bounded<5>() * ::capnp::POINTERS));
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsFile() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<96>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsFile() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<96>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsFile(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<96>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsConst() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<97>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsConst() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<97>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsConst(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<97>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsEnum() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<98>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsEnum() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<98>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsEnum(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<98>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsEnumerant() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<99>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsEnumerant() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<99>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsEnumerant(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<99>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsStruct() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<100>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsStruct() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<100>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsStruct(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<100>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsField() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<101>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsField() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<101>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsField(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<101>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsUnion() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<102>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsUnion() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<102>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsUnion(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<102>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsGroup() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<103>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsGroup() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<103>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsGroup(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<103>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsInterface() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<104>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsInterface() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<104>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsInterface(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<104>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsMethod() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<105>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsMethod() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<105>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsMethod(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<105>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsParam() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<106>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsParam() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<106>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsParam(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<106>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Declaration::Annotation::Reader::getTargetsAnnotation() const {
+ return _reader.getDataField<bool>(
+ ::capnp::bounded<107>() * ::capnp::ELEMENTS);
+}
+
+inline bool Declaration::Annotation::Builder::getTargetsAnnotation() {
+ return _builder.getDataField<bool>(
+ ::capnp::bounded<107>() * ::capnp::ELEMENTS);
+}
+inline void Declaration::Annotation::Builder::setTargetsAnnotation(bool value) {
+ _builder.setDataField<bool>(
+ ::capnp::bounded<107>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool ParsedFile::Reader::hasRoot() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool ParsedFile::Builder::hasRoot() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::compiler::Declaration::Reader ParsedFile::Reader::getRoot() const {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::compiler::Declaration::Builder ParsedFile::Builder::getRoot() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+#if !CAPNP_LITE
+inline ::capnp::compiler::Declaration::Pipeline ParsedFile::Pipeline::getRoot() {
+ return ::capnp::compiler::Declaration::Pipeline(_typeless.getPointerField(0));
+}
+#endif // !CAPNP_LITE
+inline void ParsedFile::Builder::setRoot( ::capnp::compiler::Declaration::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::compiler::Declaration::Builder ParsedFile::Builder::initRoot() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void ParsedFile::Builder::adoptRoot(
+ ::capnp::Orphan< ::capnp::compiler::Declaration>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::compiler::Declaration> ParsedFile::Builder::disownRoot() {
+ return ::capnp::_::PointerHelpers< ::capnp::compiler::Declaration>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+} // namespace
+} // namespace
+
+#endif // CAPNP_INCLUDED_c56be168dcbbc3c6_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/lexer.capnp.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/lexer.capnp.h
new file mode 100644
index 0000000..0526751
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/lexer.capnp.h
@@ -0,0 +1,1242 @@
+// Generated by Cap'n Proto compiler, DO NOT EDIT
+// source: lexer.capnp
+
+#ifndef CAPNP_INCLUDED_a73956d2621fc3ee_
+#define CAPNP_INCLUDED_a73956d2621fc3ee_
+
+#include <capnp/generated-header-support.h>
+
+#if CAPNP_VERSION != 7000
+#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(91cc55cd57de5419);
+CAPNP_DECLARE_SCHEMA(c6725e678d60fa37);
+CAPNP_DECLARE_SCHEMA(9e69a92512b19d18);
+CAPNP_DECLARE_SCHEMA(a11f97b9d6c73dd4);
+
+} // namespace schemas
+} // namespace capnp
+
+namespace capnp {
+namespace compiler {
+
+struct Token {
+ Token() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ IDENTIFIER,
+ STRING_LITERAL,
+ INTEGER_LITERAL,
+ FLOAT_LITERAL,
+ OPERATOR,
+ PARENTHESIZED_LIST,
+ BRACKETED_LIST,
+ BINARY_LITERAL,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(91cc55cd57de5419, 3, 1)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct Statement {
+ Statement() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+ enum Which: uint16_t {
+ LINE,
+ BLOCK,
+ };
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(c6725e678d60fa37, 2, 3)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct LexedTokens {
+ LexedTokens() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(9e69a92512b19d18, 0, 1)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+struct LexedStatements {
+ LexedStatements() = delete;
+
+ class Reader;
+ class Builder;
+ class Pipeline;
+
+ struct _capnpPrivate {
+ CAPNP_DECLARE_STRUCT_HEADER(a11f97b9d6c73dd4, 0, 1)
+ #if !CAPNP_LITE
+ static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
+ #endif // !CAPNP_LITE
+ };
+};
+
+// =======================================================================================
+
+class Token::Reader {
+public:
+ typedef Token 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 Which which() const;
+ inline bool isIdentifier() const;
+ inline bool hasIdentifier() const;
+ inline ::capnp::Text::Reader getIdentifier() const;
+
+ inline bool isStringLiteral() const;
+ inline bool hasStringLiteral() const;
+ inline ::capnp::Text::Reader getStringLiteral() const;
+
+ inline bool isIntegerLiteral() const;
+ inline ::uint64_t getIntegerLiteral() const;
+
+ inline bool isFloatLiteral() const;
+ inline double getFloatLiteral() const;
+
+ inline bool isOperator() const;
+ inline bool hasOperator() const;
+ inline ::capnp::Text::Reader getOperator() const;
+
+ inline bool isParenthesizedList() const;
+ inline bool hasParenthesizedList() const;
+ inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader getParenthesizedList() const;
+
+ inline bool isBracketedList() const;
+ inline bool hasBracketedList() const;
+ inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader getBracketedList() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+ inline bool isBinaryLiteral() const;
+ inline bool hasBinaryLiteral() const;
+ inline ::capnp::Data::Reader getBinaryLiteral() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Token::Builder {
+public:
+ typedef Token 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 Which which();
+ inline bool isIdentifier();
+ inline bool hasIdentifier();
+ inline ::capnp::Text::Builder getIdentifier();
+ inline void setIdentifier( ::capnp::Text::Reader value);
+ inline ::capnp::Text::Builder initIdentifier(unsigned int size);
+ inline void adoptIdentifier(::capnp::Orphan< ::capnp::Text>&& value);
+ inline ::capnp::Orphan< ::capnp::Text> disownIdentifier();
+
+ inline bool isStringLiteral();
+ inline bool hasStringLiteral();
+ inline ::capnp::Text::Builder getStringLiteral();
+ inline void setStringLiteral( ::capnp::Text::Reader value);
+ inline ::capnp::Text::Builder initStringLiteral(unsigned int size);
+ inline void adoptStringLiteral(::capnp::Orphan< ::capnp::Text>&& value);
+ inline ::capnp::Orphan< ::capnp::Text> disownStringLiteral();
+
+ inline bool isIntegerLiteral();
+ inline ::uint64_t getIntegerLiteral();
+ inline void setIntegerLiteral( ::uint64_t value);
+
+ inline bool isFloatLiteral();
+ inline double getFloatLiteral();
+ inline void setFloatLiteral(double value);
+
+ inline bool isOperator();
+ inline bool hasOperator();
+ inline ::capnp::Text::Builder getOperator();
+ inline void setOperator( ::capnp::Text::Reader value);
+ inline ::capnp::Text::Builder initOperator(unsigned int size);
+ inline void adoptOperator(::capnp::Orphan< ::capnp::Text>&& value);
+ inline ::capnp::Orphan< ::capnp::Text> disownOperator();
+
+ inline bool isParenthesizedList();
+ inline bool hasParenthesizedList();
+ inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Builder getParenthesizedList();
+ inline void setParenthesizedList( ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader value);
+ inline void setParenthesizedList(::kj::ArrayPtr<const ::capnp::List< ::capnp::compiler::Token>::Reader> value);
+ inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Builder initParenthesizedList(unsigned int size);
+ inline void adoptParenthesizedList(::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>> disownParenthesizedList();
+
+ inline bool isBracketedList();
+ inline bool hasBracketedList();
+ inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Builder getBracketedList();
+ inline void setBracketedList( ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader value);
+ inline void setBracketedList(::kj::ArrayPtr<const ::capnp::List< ::capnp::compiler::Token>::Reader> value);
+ inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Builder initBracketedList(unsigned int size);
+ inline void adoptBracketedList(::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>> disownBracketedList();
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+ inline bool isBinaryLiteral();
+ inline bool hasBinaryLiteral();
+ inline ::capnp::Data::Builder getBinaryLiteral();
+ inline void setBinaryLiteral( ::capnp::Data::Reader value);
+ inline ::capnp::Data::Builder initBinaryLiteral(unsigned int size);
+ inline void adoptBinaryLiteral(::capnp::Orphan< ::capnp::Data>&& value);
+ inline ::capnp::Orphan< ::capnp::Data> disownBinaryLiteral();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Token::Pipeline {
+public:
+ typedef Token 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class Statement::Reader {
+public:
+ typedef Statement 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 Which which() const;
+ inline bool hasTokens() const;
+ inline ::capnp::List< ::capnp::compiler::Token>::Reader getTokens() const;
+
+ inline bool isLine() const;
+ inline ::capnp::Void getLine() const;
+
+ inline bool isBlock() const;
+ inline bool hasBlock() const;
+ inline ::capnp::List< ::capnp::compiler::Statement>::Reader getBlock() const;
+
+ inline bool hasDocComment() const;
+ inline ::capnp::Text::Reader getDocComment() const;
+
+ inline ::uint32_t getStartByte() const;
+
+ inline ::uint32_t getEndByte() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class Statement::Builder {
+public:
+ typedef Statement 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 Which which();
+ inline bool hasTokens();
+ inline ::capnp::List< ::capnp::compiler::Token>::Builder getTokens();
+ inline void setTokens( ::capnp::List< ::capnp::compiler::Token>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Token>::Builder initTokens(unsigned int size);
+ inline void adoptTokens(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>> disownTokens();
+
+ inline bool isLine();
+ inline ::capnp::Void getLine();
+ inline void setLine( ::capnp::Void value = ::capnp::VOID);
+
+ inline bool isBlock();
+ inline bool hasBlock();
+ inline ::capnp::List< ::capnp::compiler::Statement>::Builder getBlock();
+ inline void setBlock( ::capnp::List< ::capnp::compiler::Statement>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Statement>::Builder initBlock(unsigned int size);
+ inline void adoptBlock(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>> disownBlock();
+
+ inline bool hasDocComment();
+ inline ::capnp::Text::Builder getDocComment();
+ inline void setDocComment( ::capnp::Text::Reader value);
+ inline ::capnp::Text::Builder initDocComment(unsigned int size);
+ inline void adoptDocComment(::capnp::Orphan< ::capnp::Text>&& value);
+ inline ::capnp::Orphan< ::capnp::Text> disownDocComment();
+
+ inline ::uint32_t getStartByte();
+ inline void setStartByte( ::uint32_t value);
+
+ inline ::uint32_t getEndByte();
+ inline void setEndByte( ::uint32_t value);
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class Statement::Pipeline {
+public:
+ typedef Statement 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class LexedTokens::Reader {
+public:
+ typedef LexedTokens 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 hasTokens() const;
+ inline ::capnp::List< ::capnp::compiler::Token>::Reader getTokens() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class LexedTokens::Builder {
+public:
+ typedef LexedTokens 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 hasTokens();
+ inline ::capnp::List< ::capnp::compiler::Token>::Builder getTokens();
+ inline void setTokens( ::capnp::List< ::capnp::compiler::Token>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Token>::Builder initTokens(unsigned int size);
+ inline void adoptTokens(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>> disownTokens();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class LexedTokens::Pipeline {
+public:
+ typedef LexedTokens 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+class LexedStatements::Reader {
+public:
+ typedef LexedStatements 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 hasStatements() const;
+ inline ::capnp::List< ::capnp::compiler::Statement>::Reader getStatements() const;
+
+private:
+ ::capnp::_::StructReader _reader;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::List;
+ friend class ::capnp::MessageBuilder;
+ friend class ::capnp::Orphanage;
+};
+
+class LexedStatements::Builder {
+public:
+ typedef LexedStatements 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 hasStatements();
+ inline ::capnp::List< ::capnp::compiler::Statement>::Builder getStatements();
+ inline void setStatements( ::capnp::List< ::capnp::compiler::Statement>::Reader value);
+ inline ::capnp::List< ::capnp::compiler::Statement>::Builder initStatements(unsigned int size);
+ inline void adoptStatements(::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>>&& value);
+ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>> disownStatements();
+
+private:
+ ::capnp::_::StructBuilder _builder;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+ friend class ::capnp::Orphanage;
+ template <typename, ::capnp::Kind>
+ friend struct ::capnp::_::PointerHelpers;
+};
+
+#if !CAPNP_LITE
+class LexedStatements::Pipeline {
+public:
+ typedef LexedStatements 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 <typename, ::capnp::Kind>
+ friend struct ::capnp::ToDynamic_;
+};
+#endif // !CAPNP_LITE
+
+// =======================================================================================
+
+inline ::capnp::compiler::Token::Which Token::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Token::Which Token::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline bool Token::Reader::isIdentifier() const {
+ return which() == Token::IDENTIFIER;
+}
+inline bool Token::Builder::isIdentifier() {
+ return which() == Token::IDENTIFIER;
+}
+inline bool Token::Reader::hasIdentifier() const {
+ if (which() != Token::IDENTIFIER) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Token::Builder::hasIdentifier() {
+ if (which() != Token::IDENTIFIER) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Text::Reader Token::Reader::getIdentifier() const {
+ KJ_IREQUIRE((which() == Token::IDENTIFIER),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::Text::Builder Token::Builder::getIdentifier() {
+ KJ_IREQUIRE((which() == Token::IDENTIFIER),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Token::Builder::setIdentifier( ::capnp::Text::Reader value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::IDENTIFIER);
+ ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Text::Builder Token::Builder::initIdentifier(unsigned int size) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::IDENTIFIER);
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Token::Builder::adoptIdentifier(
+ ::capnp::Orphan< ::capnp::Text>&& value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::IDENTIFIER);
+ ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Text> Token::Builder::disownIdentifier() {
+ KJ_IREQUIRE((which() == Token::IDENTIFIER),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Token::Reader::isStringLiteral() const {
+ return which() == Token::STRING_LITERAL;
+}
+inline bool Token::Builder::isStringLiteral() {
+ return which() == Token::STRING_LITERAL;
+}
+inline bool Token::Reader::hasStringLiteral() const {
+ if (which() != Token::STRING_LITERAL) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Token::Builder::hasStringLiteral() {
+ if (which() != Token::STRING_LITERAL) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Text::Reader Token::Reader::getStringLiteral() const {
+ KJ_IREQUIRE((which() == Token::STRING_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::Text::Builder Token::Builder::getStringLiteral() {
+ KJ_IREQUIRE((which() == Token::STRING_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Token::Builder::setStringLiteral( ::capnp::Text::Reader value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::STRING_LITERAL);
+ ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Text::Builder Token::Builder::initStringLiteral(unsigned int size) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::STRING_LITERAL);
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Token::Builder::adoptStringLiteral(
+ ::capnp::Orphan< ::capnp::Text>&& value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::STRING_LITERAL);
+ ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Text> Token::Builder::disownStringLiteral() {
+ KJ_IREQUIRE((which() == Token::STRING_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Token::Reader::isIntegerLiteral() const {
+ return which() == Token::INTEGER_LITERAL;
+}
+inline bool Token::Builder::isIntegerLiteral() {
+ return which() == Token::INTEGER_LITERAL;
+}
+inline ::uint64_t Token::Reader::getIntegerLiteral() const {
+ KJ_IREQUIRE((which() == Token::INTEGER_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint64_t Token::Builder::getIntegerLiteral() {
+ KJ_IREQUIRE((which() == Token::INTEGER_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Token::Builder::setIntegerLiteral( ::uint64_t value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::INTEGER_LITERAL);
+ _builder.setDataField< ::uint64_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Token::Reader::isFloatLiteral() const {
+ return which() == Token::FLOAT_LITERAL;
+}
+inline bool Token::Builder::isFloatLiteral() {
+ return which() == Token::FLOAT_LITERAL;
+}
+inline double Token::Reader::getFloatLiteral() const {
+ KJ_IREQUIRE((which() == Token::FLOAT_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField<double>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline double Token::Builder::getFloatLiteral() {
+ KJ_IREQUIRE((which() == Token::FLOAT_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField<double>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Token::Builder::setFloatLiteral(double value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::FLOAT_LITERAL);
+ _builder.setDataField<double>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Token::Reader::isOperator() const {
+ return which() == Token::OPERATOR;
+}
+inline bool Token::Builder::isOperator() {
+ return which() == Token::OPERATOR;
+}
+inline bool Token::Reader::hasOperator() const {
+ if (which() != Token::OPERATOR) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Token::Builder::hasOperator() {
+ if (which() != Token::OPERATOR) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Text::Reader Token::Reader::getOperator() const {
+ KJ_IREQUIRE((which() == Token::OPERATOR),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::Text::Builder Token::Builder::getOperator() {
+ KJ_IREQUIRE((which() == Token::OPERATOR),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Token::Builder::setOperator( ::capnp::Text::Reader value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::OPERATOR);
+ ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Text::Builder Token::Builder::initOperator(unsigned int size) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::OPERATOR);
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Token::Builder::adoptOperator(
+ ::capnp::Orphan< ::capnp::Text>&& value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::OPERATOR);
+ ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Text> Token::Builder::disownOperator() {
+ KJ_IREQUIRE((which() == Token::OPERATOR),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Token::Reader::isParenthesizedList() const {
+ return which() == Token::PARENTHESIZED_LIST;
+}
+inline bool Token::Builder::isParenthesizedList() {
+ return which() == Token::PARENTHESIZED_LIST;
+}
+inline bool Token::Reader::hasParenthesizedList() const {
+ if (which() != Token::PARENTHESIZED_LIST) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Token::Builder::hasParenthesizedList() {
+ if (which() != Token::PARENTHESIZED_LIST) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader Token::Reader::getParenthesizedList() const {
+ KJ_IREQUIRE((which() == Token::PARENTHESIZED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Builder Token::Builder::getParenthesizedList() {
+ KJ_IREQUIRE((which() == Token::PARENTHESIZED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Token::Builder::setParenthesizedList( ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::PARENTHESIZED_LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline void Token::Builder::setParenthesizedList(::kj::ArrayPtr<const ::capnp::List< ::capnp::compiler::Token>::Reader> value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::PARENTHESIZED_LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Builder Token::Builder::initParenthesizedList(unsigned int size) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::PARENTHESIZED_LIST);
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Token::Builder::adoptParenthesizedList(
+ ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>&& value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::PARENTHESIZED_LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>> Token::Builder::disownParenthesizedList() {
+ KJ_IREQUIRE((which() == Token::PARENTHESIZED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Token::Reader::isBracketedList() const {
+ return which() == Token::BRACKETED_LIST;
+}
+inline bool Token::Builder::isBracketedList() {
+ return which() == Token::BRACKETED_LIST;
+}
+inline bool Token::Reader::hasBracketedList() const {
+ if (which() != Token::BRACKETED_LIST) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Token::Builder::hasBracketedList() {
+ if (which() != Token::BRACKETED_LIST) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader Token::Reader::getBracketedList() const {
+ KJ_IREQUIRE((which() == Token::BRACKETED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Builder Token::Builder::getBracketedList() {
+ KJ_IREQUIRE((which() == Token::BRACKETED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Token::Builder::setBracketedList( ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::BRACKETED_LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline void Token::Builder::setBracketedList(::kj::ArrayPtr<const ::capnp::List< ::capnp::compiler::Token>::Reader> value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::BRACKETED_LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Builder Token::Builder::initBracketedList(unsigned int size) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::BRACKETED_LIST);
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Token::Builder::adoptBracketedList(
+ ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>&& value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::BRACKETED_LIST);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>> Token::Builder::disownBracketedList() {
+ KJ_IREQUIRE((which() == Token::BRACKETED_LIST),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline ::uint32_t Token::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Token::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Token::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t Token::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<4>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Token::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<4>() * ::capnp::ELEMENTS);
+}
+inline void Token::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<4>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Token::Reader::isBinaryLiteral() const {
+ return which() == Token::BINARY_LITERAL;
+}
+inline bool Token::Builder::isBinaryLiteral() {
+ return which() == Token::BINARY_LITERAL;
+}
+inline bool Token::Reader::hasBinaryLiteral() const {
+ if (which() != Token::BINARY_LITERAL) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Token::Builder::hasBinaryLiteral() {
+ if (which() != Token::BINARY_LITERAL) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Data::Reader Token::Reader::getBinaryLiteral() const {
+ KJ_IREQUIRE((which() == Token::BINARY_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::Data::Builder Token::Builder::getBinaryLiteral() {
+ KJ_IREQUIRE((which() == Token::BINARY_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Data>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Token::Builder::setBinaryLiteral( ::capnp::Data::Reader value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::BINARY_LITERAL);
+ ::capnp::_::PointerHelpers< ::capnp::Data>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Data::Builder Token::Builder::initBinaryLiteral(unsigned int size) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::BINARY_LITERAL);
+ return ::capnp::_::PointerHelpers< ::capnp::Data>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Token::Builder::adoptBinaryLiteral(
+ ::capnp::Orphan< ::capnp::Data>&& value) {
+ _builder.setDataField<Token::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Token::BINARY_LITERAL);
+ ::capnp::_::PointerHelpers< ::capnp::Data>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Data> Token::Builder::disownBinaryLiteral() {
+ KJ_IREQUIRE((which() == Token::BINARY_LITERAL),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::Data>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline ::capnp::compiler::Statement::Which Statement::Reader::which() const {
+ return _reader.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline ::capnp::compiler::Statement::Which Statement::Builder::which() {
+ return _builder.getDataField<Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline bool Statement::Reader::hasTokens() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool Statement::Builder::hasTokens() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Token>::Reader Statement::Reader::getTokens() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Token>::Builder Statement::Builder::getTokens() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void Statement::Builder::setTokens( ::capnp::List< ::capnp::compiler::Token>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Token>::Builder Statement::Builder::initTokens(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void Statement::Builder::adoptTokens(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>> Statement::Builder::disownTokens() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool Statement::Reader::isLine() const {
+ return which() == Statement::LINE;
+}
+inline bool Statement::Builder::isLine() {
+ return which() == Statement::LINE;
+}
+inline ::capnp::Void Statement::Reader::getLine() const {
+ KJ_IREQUIRE((which() == Statement::LINE),
+ "Must check which() before get()ing a union member.");
+ return _reader.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+
+inline ::capnp::Void Statement::Builder::getLine() {
+ KJ_IREQUIRE((which() == Statement::LINE),
+ "Must check which() before get()ing a union member.");
+ return _builder.getDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS);
+}
+inline void Statement::Builder::setLine( ::capnp::Void value) {
+ _builder.setDataField<Statement::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Statement::LINE);
+ _builder.setDataField< ::capnp::Void>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool Statement::Reader::isBlock() const {
+ return which() == Statement::BLOCK;
+}
+inline bool Statement::Builder::isBlock() {
+ return which() == Statement::BLOCK;
+}
+inline bool Statement::Reader::hasBlock() const {
+ if (which() != Statement::BLOCK) return false;
+ return !_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline bool Statement::Builder::hasBlock() {
+ if (which() != Statement::BLOCK) return false;
+ return !_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Statement>::Reader Statement::Reader::getBlock() const {
+ KJ_IREQUIRE((which() == Statement::BLOCK),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::get(_reader.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Statement>::Builder Statement::Builder::getBlock() {
+ KJ_IREQUIRE((which() == Statement::BLOCK),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::get(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+inline void Statement::Builder::setBlock( ::capnp::List< ::capnp::compiler::Statement>::Reader value) {
+ _builder.setDataField<Statement::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Statement::BLOCK);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::set(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Statement>::Builder Statement::Builder::initBlock(unsigned int size) {
+ _builder.setDataField<Statement::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Statement::BLOCK);
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::init(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), size);
+}
+inline void Statement::Builder::adoptBlock(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>>&& value) {
+ _builder.setDataField<Statement::Which>(
+ ::capnp::bounded<0>() * ::capnp::ELEMENTS, Statement::BLOCK);
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>> Statement::Builder::disownBlock() {
+ KJ_IREQUIRE((which() == Statement::BLOCK),
+ "Must check which() before get()ing a union member.");
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::disown(_builder.getPointerField(
+ ::capnp::bounded<1>() * ::capnp::POINTERS));
+}
+
+inline bool Statement::Reader::hasDocComment() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
+}
+inline bool Statement::Builder::hasDocComment() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::Text::Reader Statement::Reader::getDocComment() const {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+inline ::capnp::Text::Builder Statement::Builder::getDocComment() {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+inline void Statement::Builder::setDocComment( ::capnp::Text::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::Text::Builder Statement::Builder::initDocComment(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), size);
+}
+inline void Statement::Builder::adoptDocComment(
+ ::capnp::Orphan< ::capnp::Text>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::Text> Statement::Builder::disownDocComment() {
+ return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
+ ::capnp::bounded<2>() * ::capnp::POINTERS));
+}
+
+inline ::uint32_t Statement::Reader::getStartByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Statement::Builder::getStartByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS);
+}
+inline void Statement::Builder::setStartByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
+}
+
+inline ::uint32_t Statement::Reader::getEndByte() const {
+ return _reader.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+
+inline ::uint32_t Statement::Builder::getEndByte() {
+ return _builder.getDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS);
+}
+inline void Statement::Builder::setEndByte( ::uint32_t value) {
+ _builder.setDataField< ::uint32_t>(
+ ::capnp::bounded<2>() * ::capnp::ELEMENTS, value);
+}
+
+inline bool LexedTokens::Reader::hasTokens() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool LexedTokens::Builder::hasTokens() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Token>::Reader LexedTokens::Reader::getTokens() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Token>::Builder LexedTokens::Builder::getTokens() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void LexedTokens::Builder::setTokens( ::capnp::List< ::capnp::compiler::Token>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Token>::Builder LexedTokens::Builder::initTokens(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void LexedTokens::Builder::adoptTokens(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>> LexedTokens::Builder::disownTokens() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+inline bool LexedStatements::Reader::hasStatements() const {
+ return !_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline bool LexedStatements::Builder::hasStatements() {
+ return !_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
+}
+inline ::capnp::List< ::capnp::compiler::Statement>::Reader LexedStatements::Reader::getStatements() const {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::get(_reader.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline ::capnp::List< ::capnp::compiler::Statement>::Builder LexedStatements::Builder::getStatements() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::get(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+inline void LexedStatements::Builder::setStatements( ::capnp::List< ::capnp::compiler::Statement>::Reader value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::set(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), value);
+}
+inline ::capnp::List< ::capnp::compiler::Statement>::Builder LexedStatements::Builder::initStatements(unsigned int size) {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::init(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), size);
+}
+inline void LexedStatements::Builder::adoptStatements(
+ ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>>&& value) {
+ ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::adopt(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
+}
+inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>> LexedStatements::Builder::disownStatements() {
+ return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::disown(_builder.getPointerField(
+ ::capnp::bounded<0>() * ::capnp::POINTERS));
+}
+
+} // namespace
+} // namespace
+
+#endif // CAPNP_INCLUDED_a73956d2621fc3ee_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/lexer.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/lexer.h
new file mode 100644
index 0000000..d18923d
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/lexer.h
@@ -0,0 +1,102 @@
+// 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.
+
+#ifndef CAPNP_COMPILER_LEXER_H_
+#define CAPNP_COMPILER_LEXER_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include <capnp/compiler/lexer.capnp.h>
+#include <kj/parse/common.h>
+#include <kj/arena.h>
+#include "error-reporter.h"
+
+namespace capnp {
+namespace compiler {
+
+bool lex(kj::ArrayPtr<const char> input, LexedStatements::Builder result,
+ ErrorReporter& errorReporter);
+bool lex(kj::ArrayPtr<const char> input, LexedTokens::Builder result, ErrorReporter& errorReporter);
+// Lex the given source code, placing the results in `result`. Returns true if there
+// were no errors, false if there were. Even when errors are present, the file may have partial
+// content which can be fed into later stages of parsing in order to find more errors.
+//
+// There are two versions, one that parses a list of statements, and one which just parses tokens
+// that might form a part of one statement. In other words, in the later case, the input should
+// not contain semicolons or curly braces, unless they are in string literals of course.
+
+class Lexer {
+ // Advanced lexer interface. This interface exposes the inner parsers so that you can embed them
+ // into your own parsers.
+
+public:
+ Lexer(Orphanage orphanage, ErrorReporter& errorReporter);
+ // `orphanage` is used to allocate Cap'n Proto message objects in the result. `inputStart` is
+ // a pointer to the beginning of the input, used to compute byte offsets.
+
+ ~Lexer() noexcept(false);
+
+ class ParserInput: public kj::parse::IteratorInput<char, const char*> {
+ // Like IteratorInput<char, const char*> except that positions are measured as byte offsets
+ // rather than pointers.
+
+ public:
+ ParserInput(const char* begin, const char* end)
+ : IteratorInput<char, const char*>(begin, end), begin(begin) {}
+ explicit ParserInput(ParserInput& parent)
+ : IteratorInput<char, const char*>(parent), begin(parent.begin) {}
+
+ inline uint32_t getBest() {
+ return IteratorInput<char, const char*>::getBest() - begin;
+ }
+ inline uint32_t getPosition() {
+ return IteratorInput<char, const char*>::getPosition() - begin;
+ }
+
+ private:
+ const char* begin;
+ };
+
+ template <typename Output>
+ using Parser = kj::parse::ParserRef<ParserInput, Output>;
+
+ struct Parsers {
+ Parser<kj::Tuple<>> emptySpace;
+ Parser<Orphan<Token>> token;
+ Parser<kj::Array<Orphan<Token>>> tokenSequence;
+ Parser<Orphan<Statement>> statement;
+ Parser<kj::Array<Orphan<Statement>>> statementSequence;
+ };
+
+ const Parsers& getParsers() { return parsers; }
+
+private:
+ Orphanage orphanage;
+ kj::Arena arena;
+ Parsers parsers;
+};
+
+} // namespace compiler
+} // namespace capnp
+
+#endif // CAPNP_COMPILER_LEXER_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/module-loader.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/module-loader.h
new file mode 100644
index 0000000..86e6db2
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/module-loader.h
@@ -0,0 +1,65 @@
+// 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.
+
+#ifndef CAPNP_COMPILER_MODULE_LOADER_H_
+#define CAPNP_COMPILER_MODULE_LOADER_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include "compiler.h"
+#include "error-reporter.h"
+#include <kj/memory.h>
+#include <kj/array.h>
+#include <kj/string.h>
+
+namespace capnp {
+namespace compiler {
+
+class ModuleLoader {
+public:
+ explicit ModuleLoader(GlobalErrorReporter& errorReporter);
+ // Create a ModuleLoader that reports error messages to the given reporter.
+
+ KJ_DISALLOW_COPY(ModuleLoader);
+
+ ~ModuleLoader() noexcept(false);
+
+ void addImportPath(kj::String path);
+ // Add a directory to the list of paths that is searched for imports that start with a '/'.
+
+ kj::Maybe<Module&> loadModule(kj::StringPtr localName, kj::StringPtr sourceName);
+ // Tries to load the module with the given filename. `localName` is the path to the file on
+ // disk (as you'd pass to open(2)), and `sourceName` is the canonical name it should be given
+ // in the schema (this is used e.g. to decide output file locations). Often, these are the same.
+
+private:
+ class Impl;
+ kj::Own<Impl> impl;
+
+ class ModuleImpl;
+};
+
+} // namespace compiler
+} // namespace capnp
+
+#endif // CAPNP_COMPILER_MODULE_LOADER_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/node-translator.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/node-translator.h
new file mode 100644
index 0000000..4687000
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/node-translator.h
@@ -0,0 +1,323 @@
+// 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.
+
+#ifndef CAPNP_COMPILER_NODE_TRANSLATOR_H_
+#define CAPNP_COMPILER_NODE_TRANSLATOR_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include <capnp/orphan.h>
+#include <capnp/compiler/grammar.capnp.h>
+#include <capnp/schema.capnp.h>
+#include <capnp/dynamic.h>
+#include <kj/vector.h>
+#include <kj/one-of.h>
+#include "error-reporter.h"
+#include <map>
+
+namespace capnp {
+namespace compiler {
+
+class NodeTranslator {
+ // Translates one node in the schema from AST form to final schema form. A "node" is anything
+ // that has a unique ID, such as structs, enums, constants, and annotations, but not fields,
+ // unions, enumerants, or methods (the latter set have 16-bit ordinals but not 64-bit global IDs).
+
+public:
+ class Resolver {
+ // Callback class used to find other nodes relative to this one.
+ //
+ // TODO(cleanup): This has evolved into being a full interface for traversing the node tree.
+ // Maybe we should rename it as such, and move it out of NodeTranslator. See also
+ // TODO(cleanup) on NodeTranslator::BrandedDecl.
+
+ public:
+ struct ResolvedDecl {
+ uint64_t id;
+ uint genericParamCount;
+ uint64_t scopeId;
+ Declaration::Which kind;
+ Resolver* resolver;
+
+ kj::Maybe<schema::Brand::Reader> brand;
+ // If present, then it is necessary to replace the brand scope with the given brand before
+ // using the target type. This happens when the decl resolved to an alias; all other fields
+ // of `ResolvedDecl` refer to the target of the alias, except for `scopeId` which is the
+ // scope that contained the alias.
+ };
+
+ struct ResolvedParameter {
+ uint64_t id; // ID of the node declaring the parameter.
+ uint index; // Index of the parameter.
+ };
+
+ typedef kj::OneOf<ResolvedDecl, ResolvedParameter> ResolveResult;
+
+ virtual kj::Maybe<ResolveResult> resolve(kj::StringPtr name) = 0;
+ // Look up the given name, relative to this node, and return basic information about the
+ // target.
+
+ virtual kj::Maybe<ResolveResult> resolveMember(kj::StringPtr name) = 0;
+ // Look up a member of this node.
+
+ virtual ResolvedDecl resolveBuiltin(Declaration::Which which) = 0;
+ virtual ResolvedDecl resolveId(uint64_t id) = 0;
+
+ virtual kj::Maybe<ResolvedDecl> getParent() = 0;
+ // Returns the parent of this scope, or null if this is the top scope.
+
+ virtual ResolvedDecl getTopScope() = 0;
+ // Get the top-level scope containing this node.
+
+ virtual kj::Maybe<Schema> resolveBootstrapSchema(uint64_t id, schema::Brand::Reader brand) = 0;
+ // Get the schema for the given ID. If a schema is returned, it must be safe to traverse its
+ // dependencies via the Schema API. A schema that is only at the bootstrap stage is
+ // acceptable.
+ //
+ // Throws an exception if the id is not one that was found by calling resolve() or by
+ // traversing other schemas. Returns null if the ID is recognized, but the corresponding
+ // schema node failed to be built for reasons that were already reported.
+
+ virtual kj::Maybe<schema::Node::Reader> resolveFinalSchema(uint64_t id) = 0;
+ // Get the final schema for the given ID. A bootstrap schema is not acceptable. A raw
+ // node reader is returned rather than a Schema object because using a Schema object built
+ // by the final schema loader could trigger lazy initialization of dependencies which could
+ // lead to a cycle and deadlock.
+ //
+ // Throws an exception if the id is not one that was found by calling resolve() or by
+ // traversing other schemas. Returns null if the ID is recognized, but the corresponding
+ // schema node failed to be built for reasons that were already reported.
+
+ virtual kj::Maybe<ResolvedDecl> resolveImport(kj::StringPtr name) = 0;
+ // Get the ID of an imported file given the import path.
+
+ virtual kj::Maybe<kj::Array<const byte>> readEmbed(kj::StringPtr name) = 0;
+ // Read and return the contents of a file for an `embed` expression.
+
+ virtual kj::Maybe<Type> resolveBootstrapType(schema::Type::Reader type, Schema scope) = 0;
+ // Compile a schema::Type into a Type whose dependencies may safely be traversed via the schema
+ // API. These dependencies may have only bootstrap schemas. Returns null if the type could not
+ // be constructed due to already-reported errors.
+ };
+
+ NodeTranslator(Resolver& resolver, ErrorReporter& errorReporter,
+ const Declaration::Reader& decl, Orphan<schema::Node> wipNode,
+ bool compileAnnotations);
+ // Construct a NodeTranslator to translate the given declaration. The wipNode starts out with
+ // `displayName`, `id`, `scopeId`, and `nestedNodes` already initialized. The `NodeTranslator`
+ // fills in the rest.
+
+ ~NodeTranslator() noexcept(false);
+
+ struct NodeSet {
+ schema::Node::Reader node;
+ // The main node.
+
+ kj::Array<schema::Node::Reader> auxNodes;
+ // Auxiliary nodes that were produced when translating this node and should be loaded along
+ // with it. In particular, structs that contain groups (or named unions) spawn extra nodes
+ // representing those, and interfaces spawn struct nodes representing method params/results.
+
+ kj::Array<schema::Node::SourceInfo::Reader> sourceInfo;
+ // The SourceInfo for the node and all aux nodes.
+ };
+
+ NodeSet getBootstrapNode();
+ // Get an incomplete version of the node in which pointer-typed value expressions have not yet
+ // been translated. Instead, for all `schema.Value` objects representing pointer-type values,
+ // the value is set to an appropriate "empty" value. This version of the schema can be used to
+ // bootstrap the dynamic API which can then in turn be used to encode the missing complex values.
+ //
+ // If the final node has already been built, this will actually return the final node (in fact,
+ // it's the same node object).
+
+ NodeSet finish();
+ // Finish translating the node (including filling in all the pieces that are missing from the
+ // bootstrap node) and return it.
+
+ static kj::Maybe<Resolver::ResolveResult> compileDecl(
+ uint64_t scopeId, uint scopeParameterCount, Resolver& resolver, ErrorReporter& errorReporter,
+ Expression::Reader expression, schema::Brand::Builder brandBuilder);
+ // Compile a one-off declaration expression without building a NodeTranslator. Used for
+ // evaluating aliases.
+ //
+ // `brandBuilder` may be used to construct a message which will fill in ResolvedDecl::brand in
+ // the result.
+
+private:
+ class DuplicateNameDetector;
+ class DuplicateOrdinalDetector;
+ class StructLayout;
+ class StructTranslator;
+ class BrandedDecl;
+ class BrandScope;
+
+ Resolver& resolver;
+ ErrorReporter& errorReporter;
+ Orphanage orphanage;
+ bool compileAnnotations;
+ kj::Own<BrandScope> localBrand;
+
+ Orphan<schema::Node> wipNode;
+ // The work-in-progress schema node.
+
+ Orphan<schema::Node::SourceInfo> sourceInfo;
+ // Doc comments and other source info for this node.
+
+ struct AuxNode {
+ Orphan<schema::Node> node;
+ Orphan<schema::Node::SourceInfo> sourceInfo;
+ };
+
+ kj::Vector<AuxNode> groups;
+ // If this is a struct node and it contains groups, these are the nodes for those groups, which
+ // must be loaded together with the top-level node.
+
+ kj::Vector<AuxNode> paramStructs;
+ // If this is an interface, these are the auto-generated structs representing params and results.
+
+ struct UnfinishedValue {
+ Expression::Reader source;
+ schema::Type::Reader type;
+ Schema typeScope;
+ schema::Value::Builder target;
+ };
+ kj::Vector<UnfinishedValue> unfinishedValues;
+ // List of values in `wipNode` which have not yet been interpreted, because they are structs
+ // or lists and as such interpreting them require using the types' schemas (to take advantage
+ // of the dynamic API). Once bootstrap schemas have been built, they can be used to interpret
+ // these values.
+
+ void compileNode(Declaration::Reader decl, schema::Node::Builder builder);
+
+ void compileConst(Declaration::Const::Reader decl, schema::Node::Const::Builder builder);
+ void compileAnnotation(Declaration::Annotation::Reader decl,
+ schema::Node::Annotation::Builder builder);
+
+ void compileEnum(Void decl, List<Declaration>::Reader members,
+ schema::Node::Builder builder);
+ void compileStruct(Void decl, List<Declaration>::Reader members,
+ schema::Node::Builder builder);
+ void compileInterface(Declaration::Interface::Reader decl,
+ List<Declaration>::Reader members,
+ schema::Node::Builder builder);
+ // The `members` arrays contain only members with ordinal numbers, in code order. Other members
+ // are handled elsewhere.
+
+ struct ImplicitParams {
+ // Represents a set of implicit parameters visible in the current context.
+
+ uint64_t scopeId;
+ // If zero, then any reference to an implciit param in this context should be compiled to a
+ // `implicitMethodParam` AnyPointer. If non-zero, it should be compiled to a `parameter`
+ // AnyPointer.
+
+ List<Declaration::BrandParameter>::Reader params;
+ };
+
+ static inline ImplicitParams noImplicitParams() {
+ return { 0, List<Declaration::BrandParameter>::Reader() };
+ }
+
+ template <typename InitBrandFunc>
+ uint64_t compileParamList(kj::StringPtr methodName, uint16_t ordinal, bool isResults,
+ Declaration::ParamList::Reader paramList,
+ typename List<Declaration::BrandParameter>::Reader implicitParams,
+ InitBrandFunc&& initBrand);
+ // Compile a param (or result) list and return the type ID of the struct type.
+
+ kj::Maybe<BrandedDecl> compileDeclExpression(
+ Expression::Reader source, ImplicitParams implicitMethodParams);
+ // Compile an expression which is expected to resolve to a declaration or type expression.
+
+ bool compileType(Expression::Reader source, schema::Type::Builder target,
+ ImplicitParams implicitMethodParams);
+ // Returns false if there was a problem, in which case value expressions of this type should
+ // not be parsed.
+
+ void compileDefaultDefaultValue(schema::Type::Reader type, schema::Value::Builder target);
+ // Initializes `target` to contain the "default default" value for `type`.
+
+ void compileBootstrapValue(
+ Expression::Reader source, schema::Type::Reader type, schema::Value::Builder target,
+ Schema typeScope = Schema());
+ // Calls compileValue() if this value should be interpreted at bootstrap time. Otheriwse,
+ // adds the value to `unfinishedValues` for later evaluation.
+ //
+ // If `type` comes from some other node, `typeScope` is the schema for that node. This is only
+ // really needed for looking up generic parameter bindings, therefore if the type comes from
+ // the node being built, an empty "Schema" (the default) works here because the node being built
+ // is of course being built for all possible bindings and thus none of its generic parameters are
+ // bound.
+
+ void compileValue(Expression::Reader source, schema::Type::Reader type,
+ Schema typeScope, schema::Value::Builder target, bool isBootstrap);
+ // Interprets the value expression and initializes `target` with the result.
+
+ kj::Maybe<DynamicValue::Reader> readConstant(Expression::Reader name, bool isBootstrap);
+ // Get the value of the given constant. May return null if some error occurs, which will already
+ // have been reported.
+
+ kj::Maybe<kj::Array<const byte>> readEmbed(LocatedText::Reader filename);
+ // Read a raw file for embedding.
+
+ Orphan<List<schema::Annotation>> compileAnnotationApplications(
+ List<Declaration::AnnotationApplication>::Reader annotations,
+ kj::StringPtr targetsFlagName);
+};
+
+class ValueTranslator {
+public:
+ class Resolver {
+ public:
+ virtual kj::Maybe<DynamicValue::Reader> resolveConstant(Expression::Reader name) = 0;
+ virtual kj::Maybe<kj::Array<const byte>> readEmbed(LocatedText::Reader filename) = 0;
+ };
+
+ ValueTranslator(Resolver& resolver, ErrorReporter& errorReporter, Orphanage orphanage)
+ : resolver(resolver), errorReporter(errorReporter), orphanage(orphanage) {}
+
+ kj::Maybe<Orphan<DynamicValue>> compileValue(Expression::Reader src, Type type);
+
+ void fillStructValue(DynamicStruct::Builder builder,
+ List<Expression::Param>::Reader assignments);
+ // Interprets the given assignments and uses them to fill in the given struct builder.
+
+private:
+ Resolver& resolver;
+ ErrorReporter& errorReporter;
+ Orphanage orphanage;
+
+ Orphan<DynamicValue> compileValueInner(Expression::Reader src, Type type);
+ // Helper for compileValue().
+
+ kj::String makeNodeName(Schema node);
+ kj::String makeTypeName(Type type);
+
+ kj::Maybe<ListSchema> makeListSchemaOf(schema::Type::Reader elementType);
+};
+
+} // namespace compiler
+} // namespace capnp
+
+#endif // CAPNP_COMPILER_NODE_TRANSLATOR_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/parser.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/parser.h
new file mode 100644
index 0000000..50370af
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/parser.h
@@ -0,0 +1,151 @@
+// 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.
+
+#ifndef CAPNP_COMPILER_PARSER_H_
+#define CAPNP_COMPILER_PARSER_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include <capnp/compiler/grammar.capnp.h>
+#include <capnp/compiler/lexer.capnp.h>
+#include <kj/parse/common.h>
+#include <kj/arena.h>
+#include "error-reporter.h"
+
+namespace capnp {
+namespace compiler {
+
+void parseFile(List<Statement>::Reader statements, ParsedFile::Builder result,
+ ErrorReporter& errorReporter);
+// Parse a list of statements to build a ParsedFile.
+//
+// If any errors are reported, then the output is not usable. However, it may be passed on through
+// later stages of compilation in order to detect additional errors.
+
+uint64_t generateRandomId();
+// Generate a new random unique ID. This lives here mostly for lack of a better location.
+
+uint64_t generateChildId(uint64_t parentId, kj::StringPtr childName);
+// Generate the ID for a child node given its parent ID and name.
+
+uint64_t generateGroupId(uint64_t parentId, uint16_t groupIndex);
+// Generate the ID for a group within a struct.
+
+uint64_t generateMethodParamsId(uint64_t parentId, uint16_t methodOrdinal, bool isResults);
+// Generate the ID for a struct representing method params / results.
+//
+// TODO(cleanup): Move generate*Id() somewhere more sensible.
+
+class CapnpParser {
+ // Advanced parser interface. This interface exposes the inner parsers so that you can embed
+ // them into your own parsers.
+
+public:
+ CapnpParser(Orphanage orphanage, ErrorReporter& errorReporter);
+ // `orphanage` is used to allocate Cap'n Proto message objects in the result. `inputStart` is
+ // a pointer to the beginning of the input, used to compute byte offsets.
+
+ ~CapnpParser() noexcept(false);
+
+ KJ_DISALLOW_COPY(CapnpParser);
+
+ using ParserInput = kj::parse::IteratorInput<Token::Reader, List<Token>::Reader::Iterator>;
+ struct DeclParserResult;
+ template <typename Output>
+ using Parser = kj::parse::ParserRef<ParserInput, Output>;
+ using DeclParser = Parser<DeclParserResult>;
+
+ kj::Maybe<Orphan<Declaration>> parseStatement(
+ Statement::Reader statement, const DeclParser& parser);
+ // Parse a statement using the given parser. In addition to parsing the token sequence itself,
+ // this takes care of parsing the block (if any) and copying over the doc comment (if any).
+
+ struct DeclParserResult {
+ // DeclParser parses a sequence of tokens representing just the "line" part of the statement --
+ // i.e. everything up to the semicolon or opening curly brace.
+ //
+ // Use `parseStatement()` to avoid having to deal with this struct.
+
+ Orphan<Declaration> decl;
+ // The decl parsed so far. The decl's `docComment` and `nestedDecls` are both empty at this
+ // point.
+
+ kj::Maybe<DeclParser> memberParser;
+ // If null, the statement should not have a block. If non-null, the statement should have a
+ // block containing statements parseable by this parser.
+
+ DeclParserResult(Orphan<Declaration>&& decl, const DeclParser& memberParser)
+ : decl(kj::mv(decl)), memberParser(memberParser) {}
+ explicit DeclParserResult(Orphan<Declaration>&& decl)
+ : decl(kj::mv(decl)), memberParser(nullptr) {}
+ };
+
+ struct Parsers {
+ DeclParser genericDecl;
+ // Parser that matches any declaration type except those that have ordinals (since they are
+ // context-dependent).
+
+ DeclParser fileLevelDecl;
+ DeclParser enumLevelDecl;
+ DeclParser structLevelDecl;
+ DeclParser interfaceLevelDecl;
+ // Parsers that match genericDecl *and* the ordinal-based declaration types valid in the given
+ // contexts. Note that these may match declarations that are not actually allowed in the given
+ // contexts, as long as the grammar is unambiguous. E.g. nested types are not allowed in
+ // enums, but they'll be accepted by enumLevelDecl. A later stage of compilation should report
+ // these as errors.
+
+ Parser<Orphan<Expression>> expression;
+ Parser<Orphan<Declaration::AnnotationApplication>> annotation;
+ Parser<Orphan<LocatedInteger>> uid;
+ Parser<Orphan<LocatedInteger>> ordinal;
+ Parser<Orphan<Declaration::Param>> param;
+
+ DeclParser usingDecl;
+ DeclParser constDecl;
+ DeclParser enumDecl;
+ DeclParser enumerantDecl;
+ DeclParser structDecl;
+ DeclParser fieldDecl;
+ DeclParser unionDecl;
+ DeclParser groupDecl;
+ DeclParser interfaceDecl;
+ DeclParser methodDecl;
+ DeclParser paramDecl;
+ DeclParser annotationDecl;
+ // Parsers for individual declaration types.
+ };
+
+ const Parsers& getParsers() { return parsers; }
+
+private:
+ Orphanage orphanage;
+ ErrorReporter& errorReporter;
+ kj::Arena arena;
+ Parsers parsers;
+};
+
+} // namespace compiler
+} // namespace capnp
+
+#endif // CAPNP_COMPILER_PARSER_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/type-id.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/type-id.h
new file mode 100644
index 0000000..23d0618
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/compiler/type-id.h
@@ -0,0 +1,45 @@
+// Copyright (c) 2017 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.
+
+#ifndef CAPNP_COMPILER_TYPE_ID_H
+#define CAPNP_COMPILER_TYPE_ID_H
+
+#include <kj/string.h>
+#include <kj/array.h>
+#include <capnp/common.h>
+
+namespace capnp {
+namespace compiler {
+
+uint64_t generateChildId(uint64_t parentId, kj::StringPtr childName);
+uint64_t generateGroupId(uint64_t parentId, uint16_t groupIndex);
+uint64_t generateMethodParamsId(uint64_t parentId, uint16_t methodOrdinal, bool isResults);
+// Generate a default type ID for various symbols. These are used only if the developer did not
+// specify an ID explicitly.
+//
+// The returned ID always has the most-significant bit set. The remaining bits are generated
+// pseudo-randomly from the input using an algorithm that should produce a uniform distribution of
+// IDs.
+
+} // namespace compiler
+} // namespace capnp
+
+#endif // CAPNP_COMPILER_TYPE_ID_H
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/test-util.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/test-util.h
new file mode 100644
index 0000000..64fcaa5
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/capnp/test-util.h
@@ -0,0 +1,312 @@
+// 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.
+
+#ifndef CAPNP_TEST_UTIL_H_
+#define CAPNP_TEST_UTIL_H_
+
+#if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
+#pragma GCC system_header
+#endif
+
+#include <capnp/test.capnp.h>
+#include <iostream>
+#include "blob.h"
+#include <kj/compat/gtest.h>
+
+#if !CAPNP_LITE
+#include "dynamic.h"
+#endif // !CAPNP_LITE
+
+// TODO(cleanup): Auto-generate stringification functions for union discriminants.
+namespace capnproto_test {
+namespace capnp {
+namespace test {
+inline kj::String KJ_STRINGIFY(TestUnion::Union0::Which which) {
+ return kj::str(static_cast<uint16_t>(which));
+}
+inline kj::String KJ_STRINGIFY(TestUnion::Union1::Which which) {
+ return kj::str(static_cast<uint16_t>(which));
+}
+inline kj::String KJ_STRINGIFY(TestUnion::Union2::Which which) {
+ return kj::str(static_cast<uint16_t>(which));
+}
+inline kj::String KJ_STRINGIFY(TestUnion::Union3::Which which) {
+ return kj::str(static_cast<uint16_t>(which));
+}
+inline kj::String KJ_STRINGIFY(TestUnnamedUnion::Which which) {
+ return kj::str(static_cast<uint16_t>(which));
+}
+inline kj::String KJ_STRINGIFY(TestGroups::Groups::Which which) {
+ return kj::str(static_cast<uint16_t>(which));
+}
+inline kj::String KJ_STRINGIFY(TestInterleavedGroups::Group1::Which which) {
+ return kj::str(static_cast<uint16_t>(which));
+}
+} // namespace test
+} // namespace capnp
+} // namespace capnproto_test
+
+namespace capnp {
+namespace _ { // private
+
+inline Data::Reader data(const char* str) {
+ return Data::Reader(reinterpret_cast<const byte*>(str), strlen(str));
+}
+
+namespace test = capnproto_test::capnp::test;
+
+// We don't use "using namespace" to pull these in because then things would still compile
+// correctly if they were generated in the global namespace.
+using ::capnproto_test::capnp::test::TestAllTypes;
+using ::capnproto_test::capnp::test::TestDefaults;
+using ::capnproto_test::capnp::test::TestEnum;
+using ::capnproto_test::capnp::test::TestUnion;
+using ::capnproto_test::capnp::test::TestUnionDefaults;
+using ::capnproto_test::capnp::test::TestNestedTypes;
+using ::capnproto_test::capnp::test::TestUsing;
+using ::capnproto_test::capnp::test::TestListDefaults;
+
+void initTestMessage(TestAllTypes::Builder builder);
+void initTestMessage(TestDefaults::Builder builder);
+void initTestMessage(TestListDefaults::Builder builder);
+
+void checkTestMessage(TestAllTypes::Builder builder);
+void checkTestMessage(TestDefaults::Builder builder);
+void checkTestMessage(TestListDefaults::Builder builder);
+
+void checkTestMessage(TestAllTypes::Reader reader);
+void checkTestMessage(TestDefaults::Reader reader);
+void checkTestMessage(TestListDefaults::Reader reader);
+
+void checkTestMessageAllZero(TestAllTypes::Builder builder);
+void checkTestMessageAllZero(TestAllTypes::Reader reader);
+
+#if !CAPNP_LITE
+void initDynamicTestMessage(DynamicStruct::Builder builder);
+void initDynamicTestLists(DynamicStruct::Builder builder);
+void checkDynamicTestMessage(DynamicStruct::Builder builder);
+void checkDynamicTestLists(DynamicStruct::Builder builder);
+void checkDynamicTestMessage(DynamicStruct::Reader reader);
+void checkDynamicTestLists(DynamicStruct::Reader reader);
+void checkDynamicTestMessageAllZero(DynamicStruct::Builder builder);
+void checkDynamicTestMessageAllZero(DynamicStruct::Reader reader);
+#endif // !CAPNP_LITE
+
+template <typename T>
+inline void checkElement(T a, T b) {
+ EXPECT_EQ(a, b);
+}
+
+template <>
+inline void checkElement<float>(float a, float b) {
+ EXPECT_FLOAT_EQ(a, b);
+}
+
+template <>
+inline void checkElement<double>(double a, double b) {
+ EXPECT_DOUBLE_EQ(a, b);
+}
+
+template <typename T, typename L = typename T::Reads>
+void checkList(T reader, std::initializer_list<decltype(reader[0])> expected) {
+ ASSERT_EQ(expected.size(), reader.size());
+ for (uint i = 0; i < expected.size(); i++) {
+ checkElement<decltype(reader[0])>(expected.begin()[i], reader[i]);
+ }
+}
+
+template <typename T, typename L = typename T::Builds, bool = false>
+void checkList(T reader, std::initializer_list<decltype(typename L::Reader()[0])> expected) {
+ ASSERT_EQ(expected.size(), reader.size());
+ for (uint i = 0; i < expected.size(); i++) {
+ checkElement<decltype(typename L::Reader()[0])>(expected.begin()[i], reader[i]);
+ }
+}
+
+inline void checkList(List<test::TestOldVersion>::Reader reader,
+ std::initializer_list<int64_t> expectedData,
+ std::initializer_list<Text::Reader> expectedPointers) {
+ ASSERT_EQ(expectedData.size(), reader.size());
+ for (uint i = 0; i < expectedData.size(); i++) {
+ EXPECT_EQ(expectedData.begin()[i], reader[i].getOld1());
+ EXPECT_EQ(expectedPointers.begin()[i], reader[i].getOld2());
+ }
+}
+
+// Hack because as<>() is a template-parameter-dependent lookup everywhere below...
+#define as template as
+
+template <typename T> void expectPrimitiveEq(T a, T b) { EXPECT_EQ(a, b); }
+inline void expectPrimitiveEq(float a, float b) { EXPECT_FLOAT_EQ(a, b); }
+inline void expectPrimitiveEq(double a, double b) { EXPECT_DOUBLE_EQ(a, b); }
+inline void expectPrimitiveEq(Text::Reader a, Text::Builder b) { EXPECT_EQ(a, b); }
+inline void expectPrimitiveEq(Data::Reader a, Data::Builder b) { EXPECT_EQ(a, b); }
+
+#if !CAPNP_LITE
+template <typename Element, typename T>
+void checkList(T reader, std::initializer_list<ReaderFor<Element>> expected) {
+ auto list = reader.as<DynamicList>();
+ ASSERT_EQ(expected.size(), list.size());
+ for (uint i = 0; i < expected.size(); i++) {
+ expectPrimitiveEq(expected.begin()[i], list[i].as<Element>());
+ }
+
+ auto typed = reader.as<List<Element>>();
+ ASSERT_EQ(expected.size(), typed.size());
+ for (uint i = 0; i < expected.size(); i++) {
+ expectPrimitiveEq(expected.begin()[i], typed[i]);
+ }
+}
+#endif // !CAPNP_LITE
+
+#undef as
+
+// =======================================================================================
+// Interface implementations.
+
+#if !CAPNP_LITE
+
+class TestInterfaceImpl final: public test::TestInterface::Server {
+public:
+ TestInterfaceImpl(int& callCount);
+
+ kj::Promise<void> foo(FooContext context) override;
+
+ kj::Promise<void> baz(BazContext context) override;
+
+private:
+ int& callCount;
+};
+
+class TestExtendsImpl final: public test::TestExtends2::Server {
+public:
+ TestExtendsImpl(int& callCount);
+
+ kj::Promise<void> foo(FooContext context) override;
+
+ kj::Promise<void> grault(GraultContext context) override;
+
+private:
+ int& callCount;
+};
+
+class TestPipelineImpl final: public test::TestPipeline::Server {
+public:
+ TestPipelineImpl(int& callCount);
+
+ kj::Promise<void> getCap(GetCapContext context) override;
+ kj::Promise<void> getAnyCap(GetAnyCapContext context) override;
+
+private:
+ int& callCount;
+};
+
+class TestCallOrderImpl final: public test::TestCallOrder::Server {
+public:
+ kj::Promise<void> getCallSequence(GetCallSequenceContext context) override;
+
+private:
+ uint count = 0;
+};
+
+class TestTailCallerImpl final: public test::TestTailCaller::Server {
+public:
+ TestTailCallerImpl(int& callCount);
+
+ kj::Promise<void> foo(FooContext context) override;
+
+private:
+ int& callCount;
+};
+
+class TestTailCalleeImpl final: public test::TestTailCallee::Server {
+public:
+ TestTailCalleeImpl(int& callCount);
+
+ kj::Promise<void> foo(FooContext context) override;
+
+private:
+ int& callCount;
+};
+
+class TestMoreStuffImpl final: public test::TestMoreStuff::Server {
+public:
+ TestMoreStuffImpl(int& callCount, int& handleCount);
+
+ kj::Promise<void> getCallSequence(GetCallSequenceContext context) override;
+
+ kj::Promise<void> callFoo(CallFooContext context) override;
+
+ kj::Promise<void> callFooWhenResolved(CallFooWhenResolvedContext context) override;
+
+ kj::Promise<void> neverReturn(NeverReturnContext context) override;
+
+ kj::Promise<void> hold(HoldContext context) override;
+
+ kj::Promise<void> callHeld(CallHeldContext context) override;
+
+ kj::Promise<void> getHeld(GetHeldContext context) override;
+
+ kj::Promise<void> echo(EchoContext context) override;
+
+ kj::Promise<void> expectCancel(ExpectCancelContext context) override;
+
+ kj::Promise<void> getHandle(GetHandleContext context) override;
+
+ kj::Promise<void> getNull(GetNullContext context) override;
+
+ kj::Promise<void> getEnormousString(GetEnormousStringContext context) override;
+
+private:
+ int& callCount;
+ int& handleCount;
+ test::TestInterface::Client clientToHold = nullptr;
+
+ kj::Promise<void> loop(uint depth, test::TestInterface::Client cap, ExpectCancelContext context);
+};
+
+class TestCapDestructor final: public test::TestInterface::Server {
+ // Implementation of TestInterface that notifies when it is destroyed.
+
+public:
+ TestCapDestructor(kj::Own<kj::PromiseFulfiller<void>>&& fulfiller)
+ : fulfiller(kj::mv(fulfiller)), impl(dummy) {}
+
+ ~TestCapDestructor() {
+ fulfiller->fulfill();
+ }
+
+ kj::Promise<void> foo(FooContext context) {
+ return impl.foo(context);
+ }
+
+private:
+ kj::Own<kj::PromiseFulfiller<void>> fulfiller;
+ int dummy = 0;
+ TestInterfaceImpl impl;
+};
+
+#endif // !CAPNP_LITE
+
+} // namespace _ (private)
+} // namespace capnp
+
+#endif // TEST_UTIL_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/array.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/array.h
index 51b5dcf..3aa4ae2 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/array.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/array.h
@@ -177,6 +177,11 @@
inline T& front() { return *ptr; }
inline T& back() { return *(ptr + size_ - 1); }
+ template <typename U>
+ inline bool operator==(const U& other) const { return asPtr() == other; }
+ template <typename U>
+ inline bool operator!=(const U& other) const { return asPtr() != other; }
+
inline ArrayPtr<T> slice(size_t start, size_t end) {
KJ_IREQUIRE(start <= end && end <= size_, "Out-of-bounds Array::slice().");
return ArrayPtr<T>(ptr + start, end - start);
@@ -249,6 +254,8 @@
template <typename U>
friend class Array;
+ template <typename U>
+ friend class ArrayBuilder;
};
static_assert(!canMemcpy<Array<char>>(), "canMemcpy<>() is broken");
@@ -320,6 +327,13 @@
other.ptr = nullptr;
other.pos = nullptr;
other.endPtr = nullptr;
+ }
+ ArrayBuilder(Array<T>&& other)
+ : ptr(other.ptr), pos(other.ptr + other.size_), endPtr(pos), disposer(other.disposer) {
+ // Create an already-full ArrayBuilder from an Array of the same type. This constructor
+ // primarily exists to enable Vector<T> to be constructed from Array<T>.
+ other.ptr = nullptr;
+ other.size_ = 0;
}
KJ_DISALLOW_COPY(ArrayBuilder);
inline ~ArrayBuilder() noexcept(false) { dispose(); }
@@ -808,6 +822,15 @@
return heapArray<T>(init.begin(), init.end());
}
+#if __cplusplus > 201402L
+template <typename T, typename... Params>
+inline Array<Decay<T>> arr(T&& param1, Params&&... params) {
+ ArrayBuilder<Decay<T>> builder = heapArrayBuilder<Decay<T>>(sizeof...(params) + 1);
+ (builder.add(kj::fwd<T>(param1)), ... , builder.add(kj::fwd<Params>(params)));
+ return builder.finish();
+}
+#endif
+
} // namespace kj
#endif // KJ_ARRAY_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/common.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/common.h
index 4a908ae..cd765e5 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/common.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/common.h
@@ -455,6 +455,10 @@
// KJ_DECLTYPE_REF(i) i3(i); // i3 has type int&.
// KJ_DECLTYPE_REF(kj::mv(i)) i4(kj::mv(i)); // i4 has type int.
+template <typename T, typename U> struct IsSameType_ { static constexpr bool value = false; };
+template <typename T> struct IsSameType_<T, T> { static constexpr bool value = true; };
+template <typename T, typename U> constexpr bool isSameType() { return IsSameType_<T, U>::value; }
+
template <typename T>
struct CanConvert_ {
static int sfinae(T);
@@ -911,7 +915,6 @@
return value;
}
-private: // internal interface used by friends only
inline NullableValue() noexcept: isSet(false) {}
inline NullableValue(T&& t) noexcept(noexcept(T(instance<T&&>())))
: isSet(true) {
@@ -1089,18 +1092,32 @@
inline bool operator==(decltype(nullptr)) const { return ptr == nullptr; }
inline bool operator!=(decltype(nullptr)) const { return ptr != nullptr; }
- T& orDefault(T& defaultValue) {
+ T& orDefault(T& defaultValue) & {
if (ptr == nullptr) {
return defaultValue;
} else {
return *ptr;
}
}
- const T& orDefault(const T& defaultValue) const {
+ const T& orDefault(const T& defaultValue) const & {
if (ptr == nullptr) {
return defaultValue;
} else {
return *ptr;
+ }
+ }
+ T&& orDefault(T&& defaultValue) && {
+ if (ptr == nullptr) {
+ return kj::mv(defaultValue);
+ } else {
+ return kj::mv(*ptr);
+ }
+ }
+ const T&& orDefault(const T&& defaultValue) const && {
+ if (ptr == nullptr) {
+ return kj::mv(defaultValue);
+ } else {
+ return kj::mv(*ptr);
}
}
@@ -1163,7 +1180,7 @@
template <typename U>
inline Maybe(Maybe<U&>& other) noexcept: ptr(other.ptr) {}
template <typename U>
- inline Maybe(const Maybe<const U&>& other) noexcept: ptr(other.ptr) {}
+ inline Maybe(const Maybe<U&>& other) noexcept: ptr(const_cast<const U*>(other.ptr)) {}
inline Maybe(decltype(nullptr)) noexcept: ptr(nullptr) {}
inline Maybe& operator=(T& other) noexcept { ptr = &other; return *this; }
@@ -1230,8 +1247,31 @@
: ptr(init.begin()), size_(init.size()) {}
template <size_t size>
- inline constexpr ArrayPtr(T (&native)[size]): ptr(native), size_(size) {}
- // Construct an ArrayPtr from a native C-style array.
+ inline constexpr ArrayPtr(T (&native)[size]): ptr(native), size_(size) {
+ // Construct an ArrayPtr from a native C-style array.
+ //
+ // We disable this constructor for const char arrays because otherwise you would be able to
+ // implicitly convert a character literal to ArrayPtr<const char>, which sounds really great,
+ // except that the NUL terminator would be included, which probably isn't what you intended.
+ //
+ // TODO(someday): Maybe we should support character literals but explicitly chop off the NUL
+ // terminator. This could do the wrong thing if someone tries to construct an
+ // ArrayPtr<const char> from a non-NUL-terminated char array, but evidence suggests that all
+ // real use cases are in fact intending to remove the NUL terminator. It's convenient to be
+ // able to specify ArrayPtr<const char> as a parameter type and be able to accept strings
+ // as input in addition to arrays. Currently, you'll need overloading to support string
+ // literals in this case, but if you overload StringPtr, then you'll find that several
+ // conversions (e.g. from String and from a literal char array) become ambiguous! You end up
+ // having to overload for literal char arrays specifically which is cumbersome.
+
+ static_assert(!isSameType<T, const char>(),
+ "Can't implicitly convert literal char array to ArrayPtr because we don't know if "
+ "you meant to include the NUL terminator. We may change this in the future to "
+ "automatically drop the NUL terminator. For now, try explicitly converting to StringPtr, "
+ "which can in turn implicitly convert to ArrayPtr<const char>.");
+ static_assert(!isSameType<T, const char16_t>(), "see above");
+ static_assert(!isSameType<T, const char32_t>(), "see above");
+ }
inline operator ArrayPtr<const T>() const {
return ArrayPtr<const T>(ptr, size_);
@@ -1291,6 +1331,17 @@
}
inline bool operator!=(const ArrayPtr& other) const { return !(*this == other); }
+ template <typename U>
+ inline bool operator==(const ArrayPtr<U>& other) const {
+ if (size_ != other.size()) return false;
+ for (size_t i = 0; i < size_; i++) {
+ if (ptr[i] != other[i]) return false;
+ }
+ return true;
+ }
+ template <typename U>
+ inline bool operator!=(const ArrayPtr<U>& other) const { return !(*this == other); }
+
private:
T* ptr;
size_t size_;
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/http.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/http.h
index 8d455cc..98844ad 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/http.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/http.h
@@ -144,7 +144,7 @@
//
// HttpHeaderId::HOST
//
- // TODO(0.7): Fill this out with more common headers.
+ // TODO(soon): Fill this out with more common headers.
#define DECLARE_HEADER(id, name) \
static const HttpHeaderId id;
@@ -433,7 +433,7 @@
//
// `url` and `headers` are invalidated when the returned promise resolves.
- virtual kj::Promise<kj::Own<kj::AsyncIoStream>> connect(kj::String host);
+ virtual kj::Promise<kj::Own<kj::AsyncIoStream>> connect(kj::StringPtr host);
// Handles CONNECT requests. Only relevant for proxy clients. Default implementation throws
// UNIMPLEMENTED.
};
@@ -494,7 +494,7 @@
//
// `url` and `headers` are invalidated when the returned promise resolves.
- virtual kj::Promise<kj::Own<kj::AsyncIoStream>> connect(kj::String host);
+ virtual kj::Promise<kj::Own<kj::AsyncIoStream>> connect(kj::StringPtr host);
// Handles CONNECT requests. Only relevant for proxy services. Default implementation throws
// UNIMPLEMENTED.
};
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/readiness-io.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/readiness-io.h
new file mode 100644
index 0000000..c208172
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/readiness-io.h
@@ -0,0 +1,92 @@
+// Copyright (c) 2016 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.
+
+#ifndef KJ_COMPAT_READINESS_IO_H_
+#define KJ_COMPAT_READINESS_IO_H_
+
+#include <kj/async-io.h>
+
+namespace kj {
+
+class ReadyInputStreamWrapper {
+ // Provides readiness-based Async I/O as a wrapper around KJ's standard completion-based API, for
+ // compatibility with libraries that use readiness-based abstractions (e.g. OpenSSL).
+ //
+ // Unfortunately this requires buffering, so is not very efficient.
+
+public:
+ ReadyInputStreamWrapper(AsyncInputStream& input);
+ ~ReadyInputStreamWrapper() noexcept(false);
+ KJ_DISALLOW_COPY(ReadyInputStreamWrapper);
+
+ kj::Maybe<size_t> read(kj::ArrayPtr<byte> dst);
+ // Reads bytes into `dst`, returning the number of bytes read. Returns zero only at EOF. Returns
+ // nullptr if not ready.
+
+ kj::Promise<void> whenReady();
+ // Returns a promise that resolves when read() will return non-null.
+
+private:
+ AsyncInputStream& input;
+ kj::ForkedPromise<void> pumpTask = nullptr;
+ bool isPumping = false;
+ bool eof = false;
+
+ kj::ArrayPtr<const byte> content = nullptr; // Points to currently-valid part of `buffer`.
+ byte buffer[8192];
+};
+
+class ReadyOutputStreamWrapper {
+ // Provides readiness-based Async I/O as a wrapper around KJ's standard completion-based API, for
+ // compatibility with libraries that use readiness-based abstractions (e.g. OpenSSL).
+ //
+ // Unfortunately this requires buffering, so is not very efficient.
+
+public:
+ ReadyOutputStreamWrapper(AsyncOutputStream& output);
+ ~ReadyOutputStreamWrapper() noexcept(false);
+ KJ_DISALLOW_COPY(ReadyOutputStreamWrapper);
+
+ kj::Maybe<size_t> write(kj::ArrayPtr<const byte> src);
+ // Writes bytes from `src`, returning the number of bytes written. Never returns zero. Returns
+ // nullptr if not ready.
+
+ kj::Promise<void> whenReady();
+ // Returns a promise that resolves when write() will return non-null.
+
+private:
+ AsyncOutputStream& output;
+ ArrayPtr<const byte> segments[2];
+ kj::ForkedPromise<void> pumpTask = nullptr;
+ bool isPumping = false;
+
+ uint start = 0; // index of first byte
+ uint filled = 0; // number of bytes currently in buffer
+
+ byte buffer[8192];
+
+ kj::Promise<void> pump();
+ // Asyncronously push the buffer out to the underlying stream.
+};
+
+} // namespace kj
+
+#endif // KJ_COMPAT_READINESS_IO_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/tls.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/tls.h
new file mode 100644
index 0000000..b910471
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/compat/tls.h
@@ -0,0 +1,226 @@
+// Copyright (c) 2016 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.
+
+#ifndef KJ_COMPAT_TLS_H_
+#define KJ_COMPAT_TLS_H_
+// This file implements TLS (aka SSL) encrypted networking. It is actually a wrapper, currently
+// around OpenSSL / BoringSSL / LibreSSL, but the interface is intended to remain
+// implementation-agnostic.
+//
+// Unlike OpenSSL's API, the API defined in this file is intended to be hard to use wrong. Good
+// ciphers and settings are used by default. Certificates validation is performed automatically
+// and cannot be bypassed.
+
+#include <kj/async-io.h>
+
+namespace kj {
+
+class TlsPrivateKey;
+class TlsCertificate;
+struct TlsKeypair;
+class TlsSniCallback;
+
+enum class TlsVersion {
+ SSL_3, // avoid; cryptographically broken
+ TLS_1_0,
+ TLS_1_1,
+ TLS_1_2
+};
+
+class TlsContext {
+ // TLS system. Allocate one of these, configure it with the proper keys and certificates (or
+ // use the defaults), and then use it to wrap the standard KJ network interfaces in
+ // implementations that transparently use TLS.
+
+public:
+ struct Options {
+ Options();
+ // Initializes all values to reasonable defaults.
+
+ bool useSystemTrustStore;
+ // Whether or not to trust the system's default trust store. Default: true.
+
+ kj::ArrayPtr<const TlsCertificate> trustedCertificates;
+ // Additional certificates which should be trusted. Default: none.
+
+ TlsVersion minVersion;
+ // Minimum version. Defaults to minimum version that hasn't been cryptographically broken.
+ // If you override this, consider doing:
+ //
+ // options.minVersion = kj::max(myVersion, options.minVersion);
+
+ kj::StringPtr cipherList;
+ // OpenSSL cipher list string. The default is a curated list designed to be compatible with
+ // almost all software in curent use (specifically, based on Mozilla's "intermediate"
+ // recommendations). The defaults will change in future versions of this library to account
+ // for the latest cryptanalysis.
+ //
+ // Generally you should only specify your own `cipherList` if:
+ // - You have extreme backwards-compatibility needs and wish to enable obsolete and/or broken
+ // algorithms.
+ // - You need quickly to disable an algorithm recently discovered to be broken.
+
+ kj::Maybe<const TlsKeypair&> defaultKeypair;
+ // Default keypair to use for all connections. Required for servers; optional for clients.
+
+ kj::Maybe<TlsSniCallback&> sniCallback;
+ // Callback that can be used to choose a different key/certificate based on the specific
+ // hostname requested by the client.
+ };
+
+ TlsContext(Options options = Options());
+ ~TlsContext() noexcept(false);
+ KJ_DISALLOW_COPY(TlsContext);
+
+ kj::Promise<kj::Own<kj::AsyncIoStream>> wrapServer(kj::Own<kj::AsyncIoStream> stream);
+ // Upgrade a regular network stream to TLS and begin the initial handshake as the server. The
+ // returned promise resolves when the handshake has completed successfully.
+
+ kj::Promise<kj::Own<kj::AsyncIoStream>> wrapClient(
+ kj::Own<kj::AsyncIoStream> stream, kj::StringPtr expectedServerHostname);
+ // Upgrade a regular network stream to TLS and begin the initial handshake as a client. The
+ // returned promise resolves when the handshake has completed successfully, including validating
+ // the server's certificate.
+ //
+ // You must specify the server's hostname. This is used for two purposes:
+ // 1. It is sent to the server in the initial handshake via the TLS SNI extension, so that a
+ // server serving multiple hosts knows which certificate to use.
+ // 2. The server's certificate is validated against this hostname. If validation fails, the
+ // promise returned by wrapClient() will be broken; you'll never get a stream.
+
+ kj::Own<kj::ConnectionReceiver> wrapPort(kj::Own<kj::ConnectionReceiver> port);
+ // Upgrade a ConnectionReceiver to one that automatically upgrades all accepted connections to
+ // TLS (acting as the server).
+
+ kj::Own<kj::Network> wrapNetwork(kj::Network& network);
+ // Upgrade a Network to one that automatically upgrades all connections to TLS. The network will
+ // only accept addresses of the form "hostname" and "hostname:port" (it does not accept raw IP
+ // addresses). It will automatically use SNI and verify certificates based on these hostnames.
+
+private:
+ void* ctx; // actually type SSL_CTX, but we don't want to #include the OpenSSL headers here
+
+ static int sniCallback(void* ssl, int* ad, void* arg);
+};
+
+class TlsPrivateKey {
+ // A private key suitable for use in a TLS server.
+
+public:
+ TlsPrivateKey(kj::ArrayPtr<const byte> asn1);
+ // Parse a single binary (ASN1) private key. Supports PKCS8 keys as well as "traditional format"
+ // RSA and DSA keys. Does not accept encrypted keys; it is the caller's responsibility to
+ // decrypt.
+
+ TlsPrivateKey(kj::StringPtr pem);
+ // Parse a single PEM-encoded private key. Supports PKCS8 keys as well as "traditional format"
+ // RSA and DSA keys. Does not accept encrypted keys; it is the caller's responsibility to
+ // decrypt.
+
+ ~TlsPrivateKey() noexcept(false);
+
+ TlsPrivateKey(const TlsPrivateKey& other);
+ TlsPrivateKey& operator=(const TlsPrivateKey& other);
+ // Copy-by-refcount.
+
+ inline TlsPrivateKey(TlsPrivateKey&& other): pkey(other.pkey) { other.pkey = nullptr; }
+ inline TlsPrivateKey& operator=(TlsPrivateKey&& other) {
+ pkey = other.pkey; other.pkey = nullptr;
+ return *this;
+ }
+
+private:
+ void* pkey; // actually type EVP_PKEY*
+
+ friend class TlsContext;
+};
+
+class TlsCertificate {
+ // A TLS certificate, possibly with chained intermediate certificates.
+
+public:
+ TlsCertificate(kj::ArrayPtr<const byte> asn1);
+ // Parse a single binary (ASN1) X509 certificate.
+
+ TlsCertificate(kj::ArrayPtr<const kj::ArrayPtr<const byte>> asn1);
+ // Parse a chain of binary (ASN1) X509 certificates.
+
+ TlsCertificate(kj::StringPtr pem);
+ // Parse a PEM-encode X509 certificate or certificate chain. A chain can be constructed by
+ // concatenating multiple PEM-encoded certificates, starting with the leaf certificate.
+
+ ~TlsCertificate() noexcept(false);
+
+ TlsCertificate(const TlsCertificate& other);
+ TlsCertificate& operator=(const TlsCertificate& other);
+ // Copy-by-refcount.
+
+ inline TlsCertificate(TlsCertificate&& other) {
+ memcpy(chain, other.chain, sizeof(chain));
+ memset(other.chain, 0, sizeof(chain));
+ }
+ inline TlsCertificate& operator=(TlsCertificate&& other) {
+ memcpy(chain, other.chain, sizeof(chain));
+ memset(other.chain, 0, sizeof(chain));
+ return *this;
+ }
+
+private:
+ void* chain[10];
+ // Actually type X509*[10].
+ //
+ // Note that OpenSSL has a default maximum cert chain length of 10. Although configurable at
+ // runtime, you'd actually have to convince the _peer_ to reconfigure, which is unlikely except
+ // in specific use cases. So to avoid excess allocations we just assume a max of 10 certs.
+ //
+ // If this proves to be a problem, we should maybe use STACK_OF(X509) here, but stacks are not
+ // refcounted -- the X509_chain_up_ref() function actually allocates a new stack and uprefs all
+ // the certs.
+
+ friend class TlsContext;
+};
+
+struct TlsKeypair {
+ // A pair of a private key and a certificate, for use by a server.
+
+ TlsPrivateKey privateKey;
+ TlsCertificate certificate;
+};
+
+class TlsSniCallback {
+ // Callback object to implement Server Name Indication, in which the server is able to decide
+ // what key and certificate to use based on the hostname that the client is requesting.
+ //
+ // TODO(someday): Currently this callback is synchronous, because the OpenSSL API seems to be
+ // synchronous. Other people (e.g. Node) have figured out how to do it asynchronously, but
+ // it's unclear to me if and how this is possible while using the OpenSSL APIs. It looks like
+ // Node may be manually parsing the ClientHello message rather than relying on OpenSSL. We
+ // could do that but it's too much work for today.
+
+public:
+ virtual kj::Maybe<TlsKeypair> getKey(kj::StringPtr hostname) = 0;
+ // Get the key to use for `hostname`. Null return means use the default from
+ // TlsContext::Options::defaultKeypair.
+};
+
+} // namespace kj
+
+#endif // KJ_COMPAT_TLS_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/exception.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/exception.h
index f6c0b2d..811638e 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/exception.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/exception.h
@@ -33,6 +33,7 @@
namespace kj {
class ExceptionImpl;
+template <typename T> class Function;
class Exception {
// Exception thrown in case of fatal errors.
@@ -216,6 +217,11 @@
virtual StackTraceMode stackTraceMode();
// Returns the current preferred stack trace mode.
+ virtual Function<void(Function<void()>)> getThreadInitializer();
+ // Called just before a new thread is spawned using kj::Thread. Returns a function which should
+ // be invoked inside the new thread to initialize the thread's ExceptionCallback. The initializer
+ // function itself receives, as its parameter, the thread's main function, which it must call.
+
protected:
ExceptionCallback& next;
@@ -224,6 +230,8 @@
class RootExceptionCallback;
friend ExceptionCallback& getExceptionCallback();
+
+ friend class Thread;
};
ExceptionCallback& getExceptionCallback();
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/filesystem.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/filesystem.h
new file mode 100644
index 0000000..9e14941
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/filesystem.h
@@ -0,0 +1,923 @@
+// Copyright (c) 2015 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.
+
+#ifndef KJ_FILESYSTEM_H_
+#define KJ_FILESYSTEM_H_
+
+#include "memory.h"
+#include "io.h"
+#include <inttypes.h>
+#include "time.h" // TODO(now): problematic
+#include "function.h"
+
+namespace kj {
+
+template <typename T>
+class Vector;
+
+class PathPtr;
+
+class Path {
+ // A Path identifies a file in a directory tree.
+ //
+ // In KJ, we avoid representing paths as plain strings because this can lead to path injection
+ // bugs as well as numerous kinds of bugs relating to path parsing edge cases. The Path class's
+ // interface is designed to "make it hard to screw up".
+ //
+ // A "Path" is in fact a list of strings, each string being one component of the path (as would
+ // normally be separated by '/'s). Path components are not allowed to contain '/' nor '\0', nor
+ // are they allowed to be the special names "", ".", nor "..".
+ //
+ // If you explicitly want to parse a path that contains '/'s, ".", and "..", you must use
+ // parse() and/or eval(). However, users of this interface are encouraged to avoid parsing
+ // paths at all, and instead express paths as string arrays.
+ //
+ // Note that when using the Path class, ".." is always canonicalized in path space without
+ // consulting the actual filesystem. This means that "foo/some-symlink/../bar" is exactly
+ // equivalent to "foo/bar". This differs from the kernel's behavior when resolving paths passed
+ // to system calls: the kernel would have resolved "some-symlink" to its target physical path,
+ // and then would have interpreted ".." relative to that. In practice, the kernel's behavior is
+ // rarely what the user or programmer intended, hence canonicalizing in path space produces a
+ // better result.
+ //
+ // Path objects are "immutable": functions that "modify" the path return a new path. However,
+ // if the path being operated on is an rvalue, copying can be avoided. Hence it makes sense to
+ // write code like:
+ //
+ // Path p = ...;
+ // p = kj::mv(p).append("bar"); // in-place update, avoids string copying
+
+public:
+ Path(decltype(nullptr)); // empty path
+
+ explicit Path(StringPtr name);
+ explicit Path(String&& name);
+ // Create a Path containing only one component. `name` is a single filename; it cannot contain
+ // '/' nor '\0' nor can it be exactly "" nor "." nor "..".
+ //
+ // If you want to allow '/'s and such, you must call Path::parse(). We force you to do this to
+ // prevent path injection bugs where you didn't consider what would happen if the path contained
+ // a '/'.
+
+ explicit Path(std::initializer_list<StringPtr> parts);
+ explicit Path(ArrayPtr<const StringPtr> parts);
+ explicit Path(Array<String> parts);
+ // Construct a path from an array. Note that this means you can do:
+ //
+ // Path{"foo", "bar", "baz"} // equivalent to Path::parse("foo/bar/baz")
+
+ KJ_DISALLOW_COPY(Path);
+ Path(Path&&) = default;
+ Path& operator=(Path&&) = default;
+
+ Path clone() const;
+
+ static Path parse(StringPtr path);
+ // Parses a path in traditional format. Components are separated by '/'. Any use of "." or
+ // ".." will be canonicalized (if they can't be canonicalized, e.g. because the path starts with
+ // "..", an exception is thrown). Multiple consecutive '/'s will be collapsed. A leading '/'
+ // is NOT accepted -- if that is a problem, you probably want `eval()`. Trailing '/'s are
+ // ignored.
+
+ Path append(Path suffix) const&;
+ Path append(Path suffix) &&;
+ Path append(PathPtr suffix) const&;
+ Path append(PathPtr suffix) &&;
+ Path append(StringPtr suffix) const&;
+ Path append(StringPtr suffix) &&;
+ Path append(String suffix) const&;
+ Path append(String suffix) &&;
+ // Create a new path by appending the given path to this path.
+ //
+ // `suffix` cannot contain '/' characters. Instead, you can append an array:
+ //
+ // path.append({"foo", "bar"})
+ //
+ // Or, use Path::parse():
+ //
+ // path.append(Path::parse("foo//baz/../bar"))
+
+ Path eval(StringPtr pathText) const&;
+ Path eval(StringPtr pathText) &&;
+ // Evaluates a traditional path relative to this one. `pathText` is parsed like `parse()` would,
+ // except that:
+ // - It can contain leading ".." components that traverse up the tree.
+ // - It can have a leading '/' which completely replaces the current path.
+ //
+ // THE NAME OF THIS METHOD WAS CHOSEN TO INSPIRE FEAR.
+ //
+ // Instead of using `path.eval(str)`, always consider whether you really want
+ // `path.append(Path::parse(str))`. The former is much riskier than the latter in terms of path
+ // injection vulnerabilities.
+
+ PathPtr basename() const&;
+ Path basename() &&;
+ // Get the last component of the path. (Use `basename()[0]` to get just the string.)
+
+ PathPtr parent() const&;
+ Path parent() &&;
+ // Get the parent path.
+
+ String toString(bool absolute = false) const;
+ // Converts the path to a traditional path string, appropriate to pass to a unix system call.
+ // Never throws.
+
+ const String& operator[](size_t i) const&;
+ String operator[](size_t i) &&;
+ size_t size() const;
+ const String* begin() const;
+ const String* end() const;
+ PathPtr slice(size_t start, size_t end) const&;
+ Path slice(size_t start, size_t end) &&;
+ // A Path can be accessed as an array of strings.
+
+ Path evalWin32(StringPtr pathText) const&;
+ Path evalWin32(StringPtr pathText) &&;
+ // Evaluates a Win32-style path. Differences from `eval()` include:
+ //
+ // - Backslashes can be used as path separators.
+ // - Absolute paths begin with a drive letter followed by a colon. The drive letter, including
+ // the colon, will become the first component of the path, e.g. "c:\foo" becomes {"c:", "foo"}.
+ // - A network path like "\\host\share\path" is parsed as {"host", "share", "path"}.
+
+ String toWin32String(bool absolute = false) const;
+ // Converts the path to a Win32 path string.
+ //
+ // (In most cases you'll want to further convert the returned string from UTF-8 to UTF-16.)
+ //
+ // If `absolute` is true, the path is expected to be an absolute path, meaning the first
+ // component is a drive letter, namespace, or network host name. These are converted to their
+ // regular Win32 format -- i.e. this method does the reverse of `evalWin32()`.
+ //
+ // This throws if the path would have unexpected special meaning or is otherwise invalid on
+ // Windows, such as if it contains backslashes (within a path component), colons, or special
+ // names like "con".
+
+private:
+ Array<String> parts;
+
+ // TODO(perf): Consider unrolling one element from `parts`, so that a one-element path doesn't
+ // require allocation of an array.
+
+ enum { ALREADY_CHECKED };
+ Path(Array<String> parts, decltype(ALREADY_CHECKED));
+
+ friend class PathPtr;
+
+ static String stripNul(String input);
+ static void validatePart(StringPtr part);
+ static void evalPart(Vector<String>& parts, ArrayPtr<const char> part);
+ static Path evalImpl(Vector<String>&& parts, StringPtr path);
+ static Path evalWin32Impl(Vector<String>&& parts, StringPtr path);
+ static size_t countParts(StringPtr path);
+ static size_t countPartsWin32(StringPtr path);
+ static bool isWin32Drive(ArrayPtr<const char> part);
+ static bool isNetbiosName(ArrayPtr<const char> part);
+ static bool isWin32Special(StringPtr part);
+};
+
+class PathPtr {
+ // Points to a Path or a slice of a Path, but doesn't own it.
+ //
+ // PathPtr is to Path as ArrayPtr is to Array and StringPtr is to String.
+
+public:
+ PathPtr(decltype(nullptr));
+ PathPtr(const Path& path);
+
+ Path clone();
+ Path append(Path suffix) const;
+ Path append(PathPtr suffix) const;
+ Path append(StringPtr suffix) const;
+ Path append(String suffix) const;
+ Path eval(StringPtr pathText) const;
+ PathPtr basename() const;
+ PathPtr parent() const;
+ String toString(bool absolute = false) const;
+ const String& operator[](size_t i) const;
+ size_t size() const;
+ const String* begin() const;
+ const String* end() const;
+ PathPtr slice(size_t start, size_t end) const;
+ Path evalWin32(StringPtr pathText) const;
+ String toWin32String(bool absolute = false) const;
+ // Equivalent to the corresponding methods of `Path`.
+
+private:
+ ArrayPtr<const String> parts;
+
+ explicit PathPtr(ArrayPtr<const String> parts);
+
+ friend class Path;
+};
+
+// =======================================================================================
+// The filesystem API
+//
+// This API is strictly synchronous because, unfortunately, there's no such thing as asynchronous
+// filesystem access in practice. The filesystem drivers on Linux are written to assume they can
+// block. The AIO API is only actually asynchronous for reading/writing the raw file blocks, but if
+// the filesystem needs to be involved (to allocate blocks, update metadata, etc.) that will block.
+// It's best to imagine that the filesystem is just another tier of memory that happens to be
+// slower than RAM (which is slower than L3 cache, which is slower than L2, which is slower than
+// L1). You can't do asynchronous RAM access so why asynchronous filesystem? The only way to
+// parallelize these is using threads.
+
+class FsNode {
+ // Base class for filesystem node types.
+
+public:
+ Own<FsNode> clone();
+ // Creates a new object of exactly the same type as this one, pointing at exactly the same
+ // external object.
+ //
+ // Under the hood, this will call dup(), so the FD number will not be the same.
+
+ virtual Maybe<int> getFd() = 0;
+ // Get the underlying file descriptor, if any. Returns nullptr if this object actually isn't
+ // wrapping a file descriptor.
+
+ enum class Type {
+ FILE,
+ DIRECTORY,
+ SYMLINK,
+ BLOCK_DEVICE,
+ CHARACTER_DEVICE,
+ NAMED_PIPE,
+ SOCKET,
+ OTHER,
+ };
+
+ struct Metadata {
+ Type type = Type::FILE;
+
+ uint64_t size = 0;
+ // Logical size of the file.
+
+ uint64_t spaceUsed = 0;
+ // Physical size of the file on disk. May be smaller for sparse files, or larger for
+ // pre-allocated files.
+
+ Date lastModified = UNIX_EPOCH;
+ // Last modification time of the file.
+
+ uint linkCount = 1;
+ // Number of hard links pointing to this node.
+
+ // Not currently included:
+ // - Device / inode number: Rarely useful, and not safe to use in practice anyway.
+ // - Access control info: Differs wildly across platforms, and KJ prefers capabilities anyway.
+ // - Other timestamps: Differs across platforms.
+ // - Device number: If you care, you're probably doing platform-specific stuff anyway.
+
+ Metadata() = default;
+ Metadata(Type type, uint64_t size, uint64_t spaceUsed, Date lastModified, uint linkCount)
+ : type(type), size(size), spaceUsed(spaceUsed), lastModified(lastModified),
+ linkCount(linkCount) {}
+ // TODO(cleanup): This constructor is redundant in C++14, but needed in C++11.
+ };
+
+ virtual Metadata stat() = 0;
+
+ virtual void sync() = 0;
+ virtual void datasync() = 0;
+ // Maps to fsync() and fdatasync() system calls.
+ //
+ // Also, when creating or overwriting a file, the first call to sync() atomically links the file
+ // into the filesystem (*after* syncing the data), so than incomplete data is never visible to
+ // other processes. (In practice this works by writing into a temporary file and then rename()ing
+ // it.)
+
+protected:
+ virtual Own<FsNode> cloneFsNode() = 0;
+ // Implements clone(). Required to return an object with exactly the same type as this one.
+ // Hence, every subclass must implement this.
+};
+
+class ReadableFile: public FsNode {
+public:
+ Own<ReadableFile> clone();
+
+ String readAllText();
+ // Read all text in the file and return as a big string.
+
+ Array<byte> readAllBytes();
+ // Read all bytes in the file and return as a big byte array.
+ //
+ // This differs from mmap() in that the read is performed all at once. Future changes to the file
+ // do not affect the returned copy. Consider using mmap() instead, particularly for large files.
+
+ virtual size_t read(uint64_t offset, ArrayPtr<byte> buffer) = 0;
+ // Fills `buffer` with data starting at `offset`. Returns the number of bytes actually read --
+ // the only time this is less than `buffer.size()` is when EOF occurs mid-buffer.
+
+ virtual Array<const byte> mmap(uint64_t offset, uint64_t size) = 0;
+ // Maps the file to memory read-only. The returned array always has exactly the requested size.
+ // Depending on the capabilities of the OS and filesystem, the mapping may or may not reflect
+ // changes that happen to the file after mmap() returns.
+ //
+ // Multiple calls to mmap() on the same file may or may not return the same mapping (it is
+ // immutable, so there's no possibility of interference).
+ //
+ // If the file cannot be mmap()ed, an implementation may choose to allocate a buffer on the heap,
+ // read into it, and return that. This should only happen if a real mmap() is impossible.
+ //
+ // The returned array is always exactly the size requested. However, accessing bytes beyond the
+ // current end of the file may raise SIGBUS, or may simply return zero.
+
+ virtual Array<byte> mmapPrivate(uint64_t offset, uint64_t size) = 0;
+ // Like mmap() but returns a view that the caller can modify. Modifications will not be written
+ // to the underlying file. Every call to this method returns a unique mapping. Changes made to
+ // the underlying file by other clients may or may not be reflected in the mapping -- in fact,
+ // some changes may be reflected while others aren't, even within the same mapping.
+ //
+ // In practice this is often implemented using copy-on-write pages. When you first write to a
+ // page, a copy is made. Hence, changes to the underlying file within that page stop being
+ // reflected in the mapping.
+};
+
+class AppendableFile: public FsNode, public OutputStream {
+public:
+ Own<AppendableFile> clone();
+
+ // All methods are inherited.
+};
+
+class WritableFileMapping {
+public:
+ virtual ArrayPtr<byte> get() = 0;
+ // Gets the mapped bytes. The returned array can be modified, and those changes may be written to
+ // the underlying file, but there is no guarantee that they are written unless you subsequently
+ // call changed().
+
+ virtual void changed(ArrayPtr<byte> slice) = 0;
+ // Notifies the implementation that the given bytes have changed. For some implementations this
+ // may be a no-op while for others it may be necessary in order for the changes to be written
+ // back at all.
+ //
+ // `slice` must be a slice of `bytes()`.
+
+ virtual void sync(ArrayPtr<byte> slice) = 0;
+ // Implies `changed()`, and then waits until the range has actually been written to disk before
+ // returning.
+ //
+ // `slice` must be a slice of `bytes()`.
+};
+
+class File: public ReadableFile {
+public:
+ Own<File> clone();
+
+ void writeAll(ArrayPtr<const byte> bytes);
+ void writeAll(StringPtr text);
+ // Completely replace the file with the given bytes or text.
+
+ virtual void write(uint64_t offset, ArrayPtr<const byte> data) = 0;
+ // Write the given data starting at the given offset in the file.
+
+ virtual void zero(uint64_t offset, uint64_t size) = 0;
+ // Write zeros to the file, starting at `offset` and continuing for `size` bytes. If the platform
+ // supports it, this will "punch a hole" in the file, such that blocks that are entirely zeros
+ // do not take space on disk.
+
+ virtual void truncate(uint64_t size) = 0;
+ // Set the file end pointer to `size`. If `size` is less than the current size, data past the end
+ // is truncated. If `size` is larger than the current size, zeros are added to the end of the
+ // file. If the platform supports it, blocks containing all-zeros will not be stored to disk.
+
+ virtual Own<WritableFileMapping> mmapWritable(uint64_t offset, uint64_t size) = 0;
+ // Like ReadableFile::mmap() but returns a mapping for which any changes will be immediately
+ // visible in other mappings of the file on the same system and will eventually be written back
+ // to the file.
+
+ virtual size_t copy(uint64_t offset, ReadableFile& from, uint64_t fromOffset, uint64_t size);
+ // Copies bytes from one file to another.
+ //
+ // Copies `size` bytes or to EOF, whichever comes first. Returns the number of bytes actually
+ // copied. Hint: Pass kj::maxValue for `size` to always copy to EOF.
+ //
+ // The copy is not atomic. Concurrent writes may lead to garbage results.
+ //
+ // The default implementation performs a series of reads and writes. Subclasses can often provide
+ // superior implementations that offload the work to the OS or even implement copy-on-write.
+};
+
+class ReadableDirectory: public FsNode {
+ // Read-only subset of `Directory`.
+
+public:
+ Own<ReadableDirectory> clone();
+
+ virtual Array<String> listNames() = 0;
+ // List the contents of this directory. Does NOT include "." nor "..".
+
+ struct Entry {
+ FsNode::Type type;
+ String name;
+
+ inline bool operator< (const Entry& other) const { return name < other.name; }
+ inline bool operator> (const Entry& other) const { return name > other.name; }
+ inline bool operator<=(const Entry& other) const { return name <= other.name; }
+ inline bool operator>=(const Entry& other) const { return name >= other.name; }
+ // Convenience comparison operators to sort entries by name.
+ };
+
+ virtual Array<Entry> listEntries() = 0;
+ // List the contents of the directory including the type of each file. On some platforms and
+ // filesystems, this is just as fast as listNames(), but on others it may require stat()ing each
+ // file.
+
+ virtual bool exists(PathPtr path) = 0;
+ // Does the specified path exist?
+ //
+ // If the path is a symlink, the symlink is followed and the return value indicates if the target
+ // exists. If you want to know if the symlink exists, use lstat(). (This implies that listNames()
+ // may return names for which exists() reports false.)
+
+ FsNode::Metadata lstat(PathPtr path);
+ virtual Maybe<FsNode::Metadata> tryLstat(PathPtr path) = 0;
+ // Gets metadata about the path. If the path is a symlink, it is not followed -- the metadata
+ // describes the symlink itself. `tryLstat()` returns null if the path doesn't exist.
+
+ Own<ReadableFile> openFile(PathPtr path);
+ virtual Maybe<Own<ReadableFile>> tryOpenFile(PathPtr path) = 0;
+ // Open a file for reading.
+ //
+ // `tryOpenFile()` returns null if the path doesn't exist. Other errors still throw exceptions.
+
+ Own<ReadableDirectory> openSubdir(PathPtr path);
+ virtual Maybe<Own<ReadableDirectory>> tryOpenSubdir(PathPtr path) = 0;
+ // Opens a subdirectory.
+ //
+ // `tryOpenSubdir()` returns null if the path doesn't exist. Other errors still throw exceptions.
+
+ String readlink(PathPtr path);
+ virtual Maybe<String> tryReadlink(PathPtr path) = 0;
+ // If `path` is a symlink, reads and returns the link contents.
+ //
+ // See Directory::symlink() for warnings about symlinks.
+};
+
+enum class WriteMode {
+ // Mode for opening a file (or directory) for write.
+ //
+ // (To open a file or directory read-only, do not specify a mode.)
+ //
+ // WriteMode is a bitfield. Hence, it overloads the bitwise logic operators. To check if a
+ // particular bit is set in a bitfield, use kj::has(), like:
+ //
+ // if (kj::has(mode, WriteMode::MUST_EXIST)) {
+ // requireExists(path);
+ // }
+ //
+ // (`if (mode & WriteMode::MUST_EXIST)` doesn't work because WriteMode is an enum class, which
+ // cannot be converted to bool. Alas, C++ does not allow you to define a conversion operator
+ // on an enum type, so we can't define a conversion to bool.)
+
+ // -----------------------------------------
+ // Core flags
+ //
+ // At least one of CREATE or MODIFY must be specified. Optionally, the two flags can be combined
+ // with a bitwise-OR.
+
+ CREATE = 1,
+ // Create a new empty file.
+ //
+ // This can be OR'd with MODIFY, but not with REPLACE.
+ //
+ // When not combined with MODIFY, if the file already exists (including as a broken symlink),
+ // tryOpenFile() returns null (and openFile() throws).
+ //
+ // When combined with MODIFY, if the path already exists, it will be opened as if CREATE hadn't
+ // been specified at all. If the path refers to a broken symlink, the file at the target of the
+ // link will be created (if its parent directory exists).
+
+ MODIFY = 2,
+ // Modify an existing file.
+ //
+ // This can be OR'd with CREATE, but not with REPLACE.
+ //
+ // When not combined with CREATE, if the file doesn't exist (including if it is a broken symlink),
+ // tryOpenFile() returns null (and openFile() throws).
+ //
+ // When combined with CREATE, if the path doesn't exist, it will be created as if MODIFY hadn't
+ // been specified at all. If the path refers to a broken symlink, the file at the target of the
+ // link will be created (if its parent directory exists).
+
+ // -----------------------------------------
+ // Additional flags
+ //
+ // Any number of these may be OR'd with the core flags.
+
+ CREATE_PARENT = 4,
+ // Indicates that if the target node's parent directory doesn't exist, it should be created
+ // automatically, along with its parent, and so on. This creation is NOT atomic.
+ //
+ // This bit only makes sense with CREATE or REPLACE.
+
+ EXECUTABLE = 8,
+ // Mark this file executable, if this is a meaningful designation on the host platform.
+
+ PRIVATE = 16,
+ // Indicates that this file is sensitive and should have permissions masked so that it is only
+ // accessible by the current user.
+ //
+ // When this is not used, the platform's default access control settings are used. On Unix,
+ // that usually means the umask is applied. On Windows, it means permissions are inherited from
+ // the parent.
+};
+
+inline constexpr WriteMode operator|(WriteMode a, WriteMode b) {
+ return static_cast<WriteMode>(static_cast<uint>(a) | static_cast<uint>(b));
+}
+inline constexpr WriteMode operator&(WriteMode a, WriteMode b) {
+ return static_cast<WriteMode>(static_cast<uint>(a) & static_cast<uint>(b));
+}
+inline constexpr WriteMode operator+(WriteMode a, WriteMode b) {
+ return static_cast<WriteMode>(static_cast<uint>(a) | static_cast<uint>(b));
+}
+inline constexpr WriteMode operator-(WriteMode a, WriteMode b) {
+ return static_cast<WriteMode>(static_cast<uint>(a) & ~static_cast<uint>(b));
+}
+template <typename T, typename = EnableIf<__is_enum(T)>>
+bool has(T haystack, T needle) {
+ return (static_cast<__underlying_type(T)>(haystack) &
+ static_cast<__underlying_type(T)>(needle)) ==
+ static_cast<__underlying_type(T)>(needle);
+}
+
+enum class TransferMode {
+ // Specifies desired behavior for Directory::transfer().
+
+ MOVE,
+ // The node is moved to the new location, i.e. the old location is deleted. If possible, this
+ // move is performed without copying, otherwise it is performed as a copy followed by a delete.
+
+ LINK,
+ // The new location becomes a synonym for the old location (a "hard link"). Filesystems have
+ // varying support for this -- typically, it is not supported on directories.
+
+ COPY
+ // The new location becomes a copy of the old.
+ //
+ // Some filesystems may implement this in terms of copy-on-write.
+ //
+ // If the filesystem supports sparse files, COPY takes sparseness into account -- it will punch
+ // holes in the target file where holes exist in the source file.
+};
+
+class Directory: public ReadableDirectory {
+ // Refers to a specific directory on disk.
+ //
+ // A `Directory` object *only* provides access to children of the directory, not parents. That
+ // is, you cannot open the file "..", nor jump to the root directory with "/".
+ //
+ // On OSs that support in, a `Directory` is backed by an open handle to the directory node. This
+ // means:
+ // - If the directory is renamed on-disk, the `Directory` object still points at it.
+ // - Opening files in the directory only requires the OS to traverse the path from the directory
+ // to the file; it doesn't have to re-traverse all the way from the filesystem root.
+
+public:
+ Own<Directory> clone();
+
+ template <typename T>
+ class Replacer {
+ // Implements an atomic replacement of a file or directory, allowing changes to be made to
+ // storage in a way that avoids losing data in a power outage and prevents other processes
+ // from observing content in an inconsistent state.
+ //
+ // `T` may be `File` or `Directory`. For readability, the text below describes replacing a
+ // file, but the logic is the same for directories.
+ //
+ // When you call `Directory::replaceFile()`, a temporary file is created, but the specified
+ // path is not yet touched. You may call `get()` to obtain the temporary file object, through
+ // which you may initialize its content, knowing that no other process can see it yet. The file
+ // is atomically moved to its final path when you call `commit()`. If you destroy the Replacer
+ // without calling commit(), the temporary file is deleted.
+ //
+ // Note that most operating systems sadly do not support creating a truly unnamed temporary file
+ // and then linking it in later. Moreover, the file cannot necessarily be created in the system
+ // temporary directory because it might not be on the same filesystem as the target. Therefore,
+ // the replacement file may initially be created in the same directory as its eventual target.
+ // The implementation of Directory will choose a name that is unique and "hidden" according to
+ // the conventions of the filesystem. Additionally, the implementation of Directory will avoid
+ // returning these temporary files from its list*() methods, in order to avoid observable
+ // inconsistencies across platforms.
+ public:
+ explicit Replacer(WriteMode mode);
+
+ virtual T& get() = 0;
+ // Gets the File or Directory representing the replacement data. Fill in this object before
+ // calling commit().
+
+ void commit();
+ virtual bool tryCommit() = 0;
+ // Commit the replacement.
+ //
+ // `tryCommit()` may return false based on the CREATE/MODIFY bits passed as the WriteMode when
+ // the replacement was initiated. (If CREATE but not MODIFY was used, tryCommit() returns
+ // false to indicate that the target file already existed. If MODIFY but not CREATE was used,
+ // tryCommit() returns false to indicate that the file didn't exist.)
+ //
+ // `commit()` is atomic, meaning that there is no point in time at which other processes
+ // observing the file will see it in an intermediate state -- they will either see the old
+ // content or the complete new content. This includes in the case of a power outage or machine
+ // failure: on recovery, the file will either be in the old state or the new state, but not in
+ // some intermediate state.
+ //
+ // It's important to note that a power failure *after commit() returns* can still revert the
+ // file to its previous state. That is, `commit()` does NOT guarantee that, upon return, the
+ // new content is durable. In order to guarantee this, you must call `sync()` on the immediate
+ // parent directory of the replaced file.
+ //
+ // Note that, sadly, not all filesystems / platforms are capable of supporting all of the
+ // guarantees documented above. In such cases, commit() will make a best-effort attempt to do
+ // what it claims. Some examples of possible problems include:
+ // - Any guarantees about durability through a power outage probably require a journaling
+ // filesystem.
+ // - Many platforms do not support atomically replacing a non-empty directory. Linux does as
+ // of kernel 3.15 (via the renameat2() syscall using RENAME_EXCHANGE). Where not supported,
+ // the old directory will be moved away just before the replacement is moved into place.
+ // - Many platforms do not support atomically requiring the existence or non-existence of a
+ // file before replacing it. In these cases, commit() may have to perform the check as a
+ // separate step, with a small window for a race condition.
+ // - Many platforms do not support "unlinking" a non-empty directory, meaning that a replaced
+ // directory will need to be deconstructed by deleting all contents. If another process has
+ // the directory open when it is replaced, that process will observe the contents
+ // disappearing after the replacement (actually, a swap) has taken place. This differs from
+ // files, where a process that has opened a file before it is replaced will continue see the
+ // file's old content unchanged after the replacement.
+
+ protected:
+ const WriteMode mode;
+ };
+
+ using ReadableDirectory::openFile;
+ using ReadableDirectory::openSubdir;
+ using ReadableDirectory::tryOpenFile;
+ using ReadableDirectory::tryOpenSubdir;
+
+ Own<File> openFile(PathPtr path, WriteMode mode);
+ virtual Maybe<Own<File>> tryOpenFile(PathPtr path, WriteMode mode) = 0;
+ // Open a file for writing.
+ //
+ // `tryOpenFile()` returns null if the path is required to exist but doesn't (MODIFY or REPLACE)
+ // or if the path is required not to exist but does (CREATE or RACE).
+
+ virtual Own<Replacer<File>> replaceFile(PathPtr path, WriteMode mode) = 0;
+ // Construct a file which, when ready, will be atomically moved to `path`, replacing whatever
+ // is there already. See `Replacer<T>` for detalis.
+ //
+ // The `CREATE` and `MODIFY` bits of `mode` are not enforced until commit time, hence
+ // `replaceFile()` has no "try" variant.
+
+ virtual Own<File> createTemporary() = 0;
+ // Create a temporary file backed by this directory's filesystem, but which isn't linked into
+ // the directory tree. The file is deleted from disk when all references to it have been dropped.
+
+ Own<AppendableFile> appendFile(PathPtr path, WriteMode mode);
+ virtual Maybe<Own<AppendableFile>> tryAppendFile(PathPtr path, WriteMode mode) = 0;
+ // Opens the file for appending only. Useful for log files.
+ //
+ // If the underlying filesystem supports it, writes to the file will always be appended even if
+ // other writers are writing to the same file at the same time -- however, some implementations
+ // may instead assume that no other process is changing the file size between writes.
+
+ Own<Directory> openSubdir(PathPtr path, WriteMode mode);
+ virtual Maybe<Own<Directory>> tryOpenSubdir(PathPtr path, WriteMode mode) = 0;
+ // Opens a subdirectory for writing.
+
+ virtual Own<Replacer<Directory>> replaceSubdir(PathPtr path, WriteMode mode) = 0;
+ // Construct a directory which, when ready, will be atomically moved to `path`, replacing
+ // whatever is there already. See `Replacer<T>` for detalis.
+ //
+ // The `CREATE` and `MODIFY` bits of `mode` are not enforced until commit time, hence
+ // `replaceSubdir()` has no "try" variant.
+
+ void symlink(PathPtr linkpath, StringPtr content, WriteMode mode);
+ virtual bool trySymlink(PathPtr linkpath, StringPtr content, WriteMode mode) = 0;
+ // Create a symlink. `content` is the raw text which will be written into the symlink node.
+ // How this text is interpreted is entirely dependent on the filesystem. Note in particular that:
+ // - Windows will require a path that uses backslashes as the separator.
+ // - InMemoryDirectory does not support symlinks containing "..".
+ //
+ // Unfortunately under many implementations symlink() can be used to break out of the directory
+ // by writing an absolute path or utilizing "..". Do not call this method with a value for
+ // `target` that you don't trust.
+ //
+ // `mode` must be CREATE or REPLACE, not MODIFY. CREATE_PARENT is honored but EXECUTABLE and
+ // PRIVATE have no effect. `trySymlink()` returns false in CREATE mode when the target already
+ // exists.
+
+ void transfer(PathPtr toPath, WriteMode toMode,
+ PathPtr fromPath, TransferMode mode);
+ void transfer(PathPtr toPath, WriteMode toMode,
+ Directory& fromDirectory, PathPtr fromPath,
+ TransferMode mode);
+ virtual bool tryTransfer(PathPtr toPath, WriteMode toMode,
+ Directory& fromDirectory, PathPtr fromPath,
+ TransferMode mode);
+ virtual Maybe<bool> tryTransferTo(Directory& toDirectory, PathPtr toPath, WriteMode toMode,
+ PathPtr fromPath, TransferMode mode);
+ // Move, link, or copy a file/directory tree from one location to another.
+ //
+ // Filesystems vary in what kinds of transfers are allowed, especially for TransferMode::LINK,
+ // and whether TransferMode::MOVE is implemented as an actual move vs. copy+delete.
+ //
+ // tryTransfer() returns false if the source location didn't exist, or when `toMode` is CREATE
+ // and the target already exists. The default implementation implements only TransferMode::COPY.
+ //
+ // tryTransferTo() exists to implement double-dispatch. It should be called as a fallback by
+ // implementations of tryTransfer() in cases where the target directory would otherwise fail or
+ // perform a pessimal transfer. The default implementation returns nullptr, which the caller
+ // should interpret as: "I don't have any special optimizations; do the obvious thing."
+ //
+ // `toMode` controls how the target path is created. CREATE_PARENT is honored but EXECUTABLE and
+ // PRIVATE have no effect.
+
+ void remove(PathPtr path);
+ virtual bool tryRemove(PathPtr path) = 0;
+ // Deletes/unlinks the given path. If the path names a directory, it is recursively deleted.
+ //
+ // tryRemove() returns false if the path doesn't exist; remove() throws in this case.
+
+ // TODO(someday):
+ // - Support sockets? There's no openat()-like interface for sockets, so it's hard to support
+ // them currently. Also you'd probably want to use them with the async library.
+ // - Support named pipes? Unclear if there's a use case that isn't better-served by sockets.
+ // Then again, they can be openat()ed.
+ // - Support watching for changes (inotify). Probably also requires the async library. Also
+ // lacks openat()-like semantics.
+ // - xattrs -- linux-specific
+ // - chown/chmod/etc. -- unix-specific, ACLs, eww
+ // - set timestamps -- only needed by archiving programs/
+ // - advisory locks
+ // - sendfile?
+ // - fadvise and such
+
+private:
+ static void commitFailed(WriteMode mode);
+};
+
+class Filesystem {
+public:
+ virtual Directory& getRoot() = 0;
+ // Get the filesystem's root directory, as of the time the Filesystem object was created.
+
+ virtual Directory& getCurrent() = 0;
+ // Get the filesystem's current directory, as of the time the Filesystem object was created.
+
+ virtual PathPtr getCurrentPath() = 0;
+ // Get the path from the root to the current directory, as of the time the Filesystem object was
+ // created. Note that because a `Directory` does not provide access to its parent, if you want to
+ // follow `..` from the current directory, you must use `getCurrentPath().eval("..")` or
+ // `getCurrentPath().parent()`.
+ //
+ // This function attempts to determine the path as it appeared in the user's shell before this
+ // program was started. That means, if the user had `cd`ed into a symlink, the path through that
+ // symlink is returned, *not* the canonical path.
+ //
+ // Because of this, there is an important difference between how the operating system interprets
+ // "../foo" and what you get when you write `getCurrentPath().eval("../foo")`: The former
+ // will interpret ".." relative to the directory's canonical path, whereas the latter will
+ // interpret it relative to the path shown in the user's shell. In practice, the latter is
+ // almost always what the user wants! But the former behavior is what almost all commands do
+ // in practice, and it leads to confusion. KJ commands should implement the behavior the user
+ // expects.
+};
+
+// =======================================================================================
+
+Own<File> newInMemoryFile(Clock& clock);
+Own<Directory> newInMemoryDirectory(Clock& clock);
+// Construct file and directory objects which reside in-memory.
+//
+// InMemoryFile has the following special properties:
+// - The backing store is not sparse and never gets smaller even if you truncate the file.
+// - While a non-private memory mapping exists, the backing store cannot get larger. Any operation
+// which would expand it will throw.
+//
+// InMemoryDirectory has the following special properties:
+// - Symlinks are processed using Path::parse(). This implies tha a symlink cannot point to a
+// parent directory -- InMemoryDirectory does not know its parent.
+// - link() can link directory nodes in addition to files.
+// - link() and rename() accept any kind of Directory as `fromDirectory` -- it doesn't need to be
+// another InMemoryDirectory. However, for rename(), the from path must be a directory.
+
+Own<AppendableFile> newFileAppender(Own<File> inner);
+// Creates an AppendableFile by wrapping a File. Note that this implementation assumes it is the
+// only writer. A correct implementation should always append to the file even if other writes
+// are happening simultaneously, as is achieved with the O_APPEND flag to open(2), but that
+// behavior is not possible to emulate on top of `File`.
+
+Own<ReadableFile> newDiskReadableFile(kj::AutoCloseFd fd);
+Own<AppendableFile> newDiskAppendableFile(kj::AutoCloseFd fd);
+Own<File> newDiskFile(kj::AutoCloseFd fd);
+Own<ReadableDirectory> newDiskReadableDirectory(kj::AutoCloseFd fd);
+Own<Directory> newDiskDirectory(kj::AutoCloseFd fd);
+// Wrap a file descriptor as various filesystem types.
+
+Own<Filesystem> newDiskFilesystem();
+// Get at implementation of `Filesystem` representing the real filesystem.
+//
+// DO NOT CALL THIS except at the top level of your program, e.g. in main(). Anywhere else, you
+// should instead have your caller pass in a Filesystem object, or a specific Directory object,
+// or whatever it is that your code needs. This ensures that your code supports dependency
+// injection, which makes it more reusable and testable.
+//
+// newDiskFilesystem() reads the current working directory at the time it is called. The returned
+// object is not affected by subsequent calls to chdir().
+
+// =======================================================================================
+// inline implementation details
+
+inline Path::Path(decltype(nullptr)): parts(nullptr) {}
+inline Path::Path(std::initializer_list<StringPtr> parts)
+ : Path(arrayPtr(parts.begin(), parts.end())) {}
+inline Path::Path(Array<String> parts, decltype(ALREADY_CHECKED))
+ : parts(kj::mv(parts)) {}
+inline Path Path::clone() const { return PathPtr(*this).clone(); }
+inline Path Path::append(Path suffix) const& { return PathPtr(*this).append(kj::mv(suffix)); }
+inline Path Path::append(PathPtr suffix) const& { return PathPtr(*this).append(suffix); }
+inline Path Path::append(StringPtr suffix) const& { return append(Path(suffix)); }
+inline Path Path::append(StringPtr suffix) && { return kj::mv(*this).append(Path(suffix)); }
+inline Path Path::append(String suffix) const& { return append(Path(kj::mv(suffix))); }
+inline Path Path::append(String suffix) && { return kj::mv(*this).append(Path(kj::mv(suffix))); }
+inline Path Path::eval(StringPtr pathText) const& { return PathPtr(*this).eval(pathText); }
+inline PathPtr Path::basename() const& { return PathPtr(*this).basename(); }
+inline PathPtr Path::parent() const& { return PathPtr(*this).parent(); }
+inline const String& Path::operator[](size_t i) const& { return parts[i]; }
+inline String Path::operator[](size_t i) && { return kj::mv(parts[i]); }
+inline size_t Path::size() const { return parts.size(); }
+inline const String* Path::begin() const { return parts.begin(); }
+inline const String* Path::end() const { return parts.end(); }
+inline PathPtr Path::slice(size_t start, size_t end) const& {
+ return PathPtr(*this).slice(start, end);
+}
+inline String Path::toString(bool absolute) const { return PathPtr(*this).toString(absolute); }
+inline Path Path::evalWin32(StringPtr pathText) const& {
+ return PathPtr(*this).evalWin32(pathText);
+}
+inline String Path::toWin32String(bool absolute) const {
+ return PathPtr(*this).toWin32String(absolute);
+}
+
+inline PathPtr::PathPtr(decltype(nullptr)): parts(nullptr) {}
+inline PathPtr::PathPtr(const Path& path): parts(path.parts) {}
+inline PathPtr::PathPtr(ArrayPtr<const String> parts): parts(parts) {}
+inline Path PathPtr::append(StringPtr suffix) const { return append(Path(suffix)); }
+inline Path PathPtr::append(String suffix) const { return append(Path(kj::mv(suffix))); }
+inline const String& PathPtr::operator[](size_t i) const { return parts[i]; }
+inline size_t PathPtr::size() const { return parts.size(); }
+inline const String* PathPtr::begin() const { return parts.begin(); }
+inline const String* PathPtr::end() const { return parts.end(); }
+inline PathPtr PathPtr::slice(size_t start, size_t end) const {
+ return PathPtr(parts.slice(start, end));
+}
+
+inline Own<FsNode> FsNode::clone() { return cloneFsNode().downcast<FsNode>(); }
+inline Own<ReadableFile> ReadableFile::clone() { return cloneFsNode().downcast<ReadableFile>(); }
+inline Own<AppendableFile> AppendableFile::clone() {
+ return cloneFsNode().downcast<AppendableFile>();
+}
+inline Own<File> File::clone() { return cloneFsNode().downcast<File>(); }
+inline Own<ReadableDirectory> ReadableDirectory::clone() {
+ return cloneFsNode().downcast<ReadableDirectory>();
+}
+inline Own<Directory> Directory::clone() { return cloneFsNode().downcast<Directory>(); }
+
+inline void Directory::transfer(
+ PathPtr toPath, WriteMode toMode, PathPtr fromPath, TransferMode mode) {
+ return transfer(toPath, toMode, *this, fromPath, mode);
+}
+
+template <typename T>
+inline Directory::Replacer<T>::Replacer(WriteMode mode): mode(mode) {}
+
+template <typename T>
+void Directory::Replacer<T>::commit() {
+ if (!tryCommit()) commitFailed(mode);
+}
+
+} // namespace kj
+
+#endif // KJ_FILESYSTEM_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/miniposix.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/miniposix.h
new file mode 100644
index 0000000..111c9bc
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/miniposix.h
@@ -0,0 +1,152 @@
+// 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.
+
+#ifndef KJ_MINIPOSIX_H_
+#define KJ_MINIPOSIX_H_
+
+// This header provides a small subset of the POSIX API which also happens to be available on
+// Windows under slightly-different names.
+
+#if defined(__GNUC__) && !KJ_HEADER_WARNINGS
+#pragma GCC system_header
+#endif
+
+#if _WIN32
+#include <io.h>
+#include <direct.h>
+#include <fcntl.h> // _O_BINARY
+#else
+#include <limits.h>
+#include <errno.h>
+#endif
+
+#if !_WIN32 || __MINGW32__
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
+#if !_WIN32
+#include <sys/uio.h>
+#endif
+
+namespace kj {
+namespace miniposix {
+
+#if _WIN32 && !__MINGW32__
+// We're on Windows and not MinGW. So, we need to define wrappers for the POSIX API.
+
+typedef int ssize_t;
+
+inline ssize_t read(int fd, void* buffer, size_t size) {
+ return ::_read(fd, buffer, size);
+}
+inline ssize_t write(int fd, const void* buffer, size_t size) {
+ return ::_write(fd, buffer, size);
+}
+inline int close(int fd) {
+ return ::_close(fd);
+}
+
+#ifndef F_OK
+#define F_OK 0 // access() existence test
+#endif
+
+#ifndef S_ISREG
+#define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) // stat() regular file test
+#endif
+#ifndef S_ISDIR
+#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) // stat() directory test
+#endif
+
+#ifndef STDIN_FILENO
+#define STDIN_FILENO 0
+#endif
+#ifndef STDOUT_FILENO
+#define STDOUT_FILENO 1
+#endif
+#ifndef STDERR_FILENO
+#define STDERR_FILENO 2
+#endif
+
+#else
+// We're on a POSIX system or MinGW which already defines the wrappers for us.
+
+using ::ssize_t;
+using ::read;
+using ::write;
+using ::close;
+
+#endif
+
+#if _WIN32
+// We're on Windows, including MinGW. pipe() and mkdir() are non-standard even on MinGW.
+
+inline int pipe(int fds[2]) {
+ return ::_pipe(fds, 8192, _O_BINARY);
+}
+inline int mkdir(const char* path, int mode) {
+ return ::_mkdir(path);
+}
+
+#else
+// We're on real POSIX.
+
+using ::pipe;
+using ::mkdir;
+
+inline size_t iovMax(size_t count) {
+ // Apparently, there is a maximum number of iovecs allowed per call. I don't understand why.
+ // Most platforms define IOV_MAX but Linux defines only UIO_MAXIOV and others, like Hurd,
+ // define neither.
+ //
+ // On platforms where both IOV_MAX and UIO_MAXIOV are undefined, we poke sysconf(_SC_IOV_MAX),
+ // then try to fall back to the POSIX-mandated minimum of _XOPEN_IOV_MAX if that fails.
+ //
+ // http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html#tag_13_23_03_01
+
+#if defined(IOV_MAX)
+ // Solaris (and others?)
+ return IOV_MAX;
+#elif defined(UIO_MAXIOV)
+ // Linux
+ return UIO_MAXIOV;
+#else
+ // POSIX mystery meat
+
+ long iovmax;
+
+ errno = 0;
+ if ((iovmax = sysconf(_SC_IOV_MAX)) == -1) {
+ // assume iovmax == -1 && errno == 0 means "unbounded"
+ return errno ? _XOPEN_IOV_MAX : count;
+ } else {
+ return (size_t) iovmax;
+ }
+#endif
+}
+
+#endif
+
+} // namespace miniposix
+} // namespace kj
+
+#endif // KJ_MINIPOSIX_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/mutex.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/mutex.h
index d211ebf..76edeb2 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/mutex.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/mutex.h
@@ -67,6 +67,16 @@
// non-trivial, assert that the mutex is locked (which should be good enough to catch problems
// in unit tests). In non-debug builds, do nothing.
+#if KJ_USE_FUTEX // TODO(soon): Implement on pthread & win32
+ class Predicate {
+ public:
+ virtual bool check() = 0;
+ };
+
+ void lockWhen(Predicate& predicate);
+ // Lock (exclusively) when predicate.check() returns true.
+#endif
+
private:
#if KJ_USE_FUTEX
uint futex;
@@ -79,6 +89,11 @@
static constexpr uint EXCLUSIVE_HELD = 1u << 31;
static constexpr uint EXCLUSIVE_REQUESTED = 1u << 30;
static constexpr uint SHARED_COUNT_MASK = EXCLUSIVE_REQUESTED - 1;
+
+ struct Waiter;
+ kj::Maybe<Waiter&> waitersHead = nullptr;
+ kj::Maybe<Waiter&>* waitersTail = &waitersHead;
+ // linked list of waitUntil()s; can only modify under lock
#elif _WIN32
uintptr_t srwLock; // Actually an SRWLOCK, but don't want to #include <windows.h> in header.
@@ -249,6 +264,39 @@
inline T& getAlreadyLockedExclusive() const;
// Like `getWithoutLock()`, but asserts that the lock is already held by the calling thread.
+#if KJ_USE_FUTEX // TODO(soon): Implement on pthread & win32
+ template <typename Cond, typename Func>
+ auto when(Cond&& condition, Func&& callback) const -> decltype(callback(instance<T&>())) {
+ // Waits until condition(state) returns true, then calls callback(state) under lock.
+ //
+ // `condition`, when called, receives as its parameter a const reference to the state, which is
+ // locked (either shared or exclusive). `callback` returns a mutable reference, which is
+ // exclusively locked.
+ //
+ // `condition()` may be called multiple times, from multiple threads, while waiting for the
+ // condition to become true. It may even return true once, but then be called more times.
+ // It is guaranteed, though, that at the time `callback()` is finally called, `condition()`
+ // would currently return true (assuming it is a pure function of the guarded data).
+
+ struct PredicateImpl final: public _::Mutex::Predicate {
+ bool check() override {
+ return condition(value);
+ }
+
+ Cond&& condition;
+ const T& value;
+
+ PredicateImpl(Cond&& condition, const T& value)
+ : condition(kj::fwd<Cond>(condition)), value(value) {}
+ };
+
+ PredicateImpl impl(kj::fwd<Cond>(condition), value);
+ mutex.lockWhen(impl);
+ KJ_DEFER(mutex.unlock(_::Mutex::EXCLUSIVE));
+ return callback(value);
+ }
+#endif
+
private:
mutable _::Mutex mutex;
mutable T value;
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/one-of.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/one-of.h
index 6e143c4..7b3f965 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/one-of.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/one-of.h
@@ -81,6 +81,21 @@
return *reinterpret_cast<T*>(space);
}
+ template <typename T>
+ Maybe<T&> tryGet() {
+ if (is<T>()) {
+ return *reinterpret_cast<T*>(space);
+ } else {
+ return nullptr;
+ }
+ }
+
+ template <uint i>
+ KJ_NORETURN(void allHandled());
+ // After a series of if/else blocks handling each variant of the OneOf, have the final else
+ // block call allHandled<n>() where n is the number of variants. This will fail to compile
+ // if new variants are added in the future.
+
private:
uint tag;
@@ -150,6 +165,17 @@
}
};
+template <typename... Variants>
+template <uint i>
+void OneOf<Variants...>::allHandled() {
+ // After a series of if/else blocks handling each variant of the OneOf, have the final else
+ // block call allHandled<n>() where n is the number of variants. This will fail to compile
+ // if new variants are added in the future.
+
+ static_assert(i == sizeof...(Variants), "new OneOf variants need to be handled here");
+ KJ_UNREACHABLE;
+}
+
} // namespace kj
#endif // KJ_ONE_OF_H_
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/parse/char.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/parse/char.h
index 2e6d519..ee582bd 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/parse/char.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/parse/char.h
@@ -111,6 +111,13 @@
return (bits[c / 64] & (1ll << (c % 64))) != 0;
}
+ inline bool containsAll(ArrayPtr<const char> text) const {
+ for (char c: text) {
+ if (!contains(c)) return false;
+ }
+ return true;
+ }
+
template <typename Input>
Maybe<char> operator()(Input& input) const {
if (input.atEnd()) return nullptr;
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/thread.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/thread.h
index b17b88c..29146fb 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/thread.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/thread.h
@@ -53,7 +53,10 @@
private:
struct ThreadState {
+ ThreadState(Function<void()> func);
+
Function<void()> func;
+ Function<void(Function<void()>)> initializer;
kj::Maybe<kj::Exception> exception;
unsigned int refcount;
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/vector.h b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/vector.h
index 44613f3..f99c9e3 100644
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/vector.h
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/include/kj/vector.h
@@ -43,6 +43,7 @@
public:
inline Vector() = default;
inline explicit Vector(size_t capacity): builder(heapArrayBuilder<T>(capacity)) {}
+ inline Vector(Array<T>&& array): builder(kj::mv(array)) {}
inline operator ArrayPtr<T>() { return builder; }
inline operator ArrayPtr<const T>() const { return builder; }
@@ -69,6 +70,18 @@
setCapacity(size());
}
return builder.finish();
+ }
+
+ template <typename U>
+ inline bool operator==(const U& other) const { return asPtr() == other; }
+ template <typename U>
+ inline bool operator!=(const U& other) const { return asPtr() != other; }
+
+ inline ArrayPtr<T> slice(size_t start, size_t end) {
+ return asPtr().slice(start, end);
+ }
+ inline ArrayPtr<const T> slice(size_t start, size_t end) const {
+ return asPtr().slice(start, end);
}
template <typename... Params>
@@ -103,9 +116,7 @@
}
inline void clear() {
- while (builder.size() > 0) {
- builder.removeLast();
- }
+ builder.resize(0);
}
inline void truncate(size_t size) {
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-0.6.1.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-0.6.1.so
deleted file mode 100644
index 44becdd..0000000
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-0.6.1.so
+++ /dev/null
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-0.7-dev.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-0.7-dev.so
new file mode 100644
index 0000000..b18404c
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-0.7-dev.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-json-0.7-dev.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-json-0.7-dev.so
new file mode 100644
index 0000000..cb40c16
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-json-0.7-dev.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-json.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-json.so
new file mode 100644
index 0000000..cb40c16
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp-json.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp.so
new file mode 100644
index 0000000..b18404c
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnp.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc-0.6.1.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc-0.6.1.so
deleted file mode 100644
index db69c7d..0000000
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc-0.6.1.so
+++ /dev/null
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc-0.7-dev.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc-0.7-dev.so
new file mode 100644
index 0000000..347e32a
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc-0.7-dev.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc.so
new file mode 100644
index 0000000..347e32a
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libcapnpc.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj-0.6.1.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj-0.6.1.so
deleted file mode 100644
index b96778d..0000000
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj-0.6.1.so
+++ /dev/null
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj-0.7-dev.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj-0.7-dev.so
new file mode 100644
index 0000000..95087f8
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj-0.7-dev.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj.so
new file mode 100644
index 0000000..95087f8
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/arm64-v8a/libkj.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-0.6.1.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-0.6.1.so
deleted file mode 100644
index cd3fbb6..0000000
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-0.6.1.so
+++ /dev/null
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-0.7-dev.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-0.7-dev.so
new file mode 100644
index 0000000..0d5a86b
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-0.7-dev.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-json-0.7-dev.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-json-0.7-dev.so
new file mode 100644
index 0000000..03b04d8
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-json-0.7-dev.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-json.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-json.so
new file mode 100644
index 0000000..03b04d8
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp-json.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp.so
new file mode 100644
index 0000000..0d5a86b
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnp.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc-0.6.1.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc-0.6.1.so
deleted file mode 100644
index d60a5f5..0000000
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc-0.6.1.so
+++ /dev/null
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc-0.7-dev.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc-0.7-dev.so
new file mode 100644
index 0000000..516f122
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc-0.7-dev.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc.so
new file mode 100644
index 0000000..516f122
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libcapnpc.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj-0.6.1.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj-0.6.1.so
deleted file mode 100644
index d43ccb2..0000000
--- a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj-0.6.1.so
+++ /dev/null
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj-0.7-dev.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj-0.7-dev.so
new file mode 100644
index 0000000..1d9d6ea
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj-0.7-dev.so
Binary files differ
diff --git a/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj.so b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj.so
new file mode 100644
index 0000000..1d9d6ea
--- /dev/null
+++ b/VisitFace/RtspNativeCodec/app/libs/capnproto/lib/armeabi-v7a/libkj.so
Binary files differ
--
Gitblit v1.8.0