Skip to content

C
capnproto
Unverified Commit d76ba885 authored by Kenton Varda's avatar Kenton Varda Committed by GitHub
Browse files
Options

Merge pull request #700 from capnproto/json-annotations 

Implement annotations to control JSON parsing.
parents 0fdad20a 0591a020
Show whitespace changes
Inline Side-by-side
Showing with 1926 additions and 374 deletions
c++/Makefile.am
View file @ d76ba885
......@@ -380,7 +380,8 @@ endif LITE_MODE
test_capnpc_inputs = \
src/capnp/test.capnp \
src/capnp/test-import.capnp \
src/capnp/test-import2.capnp
src/capnp/test-import2.capnp \
src/capnp/compat/json-test.capnp
test_capnpc_outputs = \
src/capnp/test.capnp.c++ \
......@@ -388,7 +389,9 @@ test_capnpc_outputs = \
src/capnp/test-import.capnp.c++ \
src/capnp/test-import.capnp.h \
src/capnp/test-import2.capnp.c++ \
src/capnp/test-import2.capnp.h
src/capnp/test-import2.capnp.h \
src/capnp/compat/json-test.capnp.c++ \
src/capnp/compat/json-test.capnp.h
if USE_EXTERNAL_CAPNP
......
c++/src/capnp/CMakeLists.txt
View file @ d76ba885
......@@ -192,6 +192,7 @@ if(BUILD_TESTING)
test.capnp
test-import.capnp
test-import2.capnp
compat/json-test.capnp
)
set(CAPNPC_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/test_capnp")
......
c++/src/capnp/compat/json-test.c++
View file @ d76ba885
......@@ -22,6 +22,7 @@
#include "json.h"
#include <capnp/test-util.h>
#include <capnp/compat/json.capnp.h>
#include <capnp/compat/json-test.capnp.h>
#include <kj/debug.h>
#include <kj/string.h>
#include <kj/test.h>
......@@ -822,6 +823,147 @@ KJ_TEST("register capability handler") {
json.addTypeHandler(handler);
}
static constexpr kj::StringPtr GOLDEN_ANNOTATED =
R"({ "names-can_contain!anything Really": "foo",
"flatFoo": 123,
"flatBar": "abc",
"renamed-flatBaz": {"hello": true},
"flatQux": "cba",
"pfx.foo": "this is a long string in order to force multi-line pretty printing",
"pfx.renamed-bar": 321,
"pfx.baz": {"hello": true},
"pfx.xfp.qux": "fed",
"union-type": "renamed-bar",
"barMember": 789,
"multiMember": "ghi",
"dependency": {"renamed-foo": "corge"},
"simpleGroup": {"renamed-grault": "garply"},
"enums": ["qux", "renamed-bar", "foo", "renamed-baz"],
"innerJson": [123, "hello", {"object": true}],
"customFieldHandler": "add-prefix-waldo",
"testBase64": "ZnJlZA==",
"testHex": "706c756768",
"bUnion": "renamed-bar",
"bValue": 678 })"_kj;
static constexpr kj::StringPtr GOLDEN_ANNOTATED_REVERSE =
R"({
"bValue": 678,
"bUnion": "renamed-bar",
"testHex": "706c756768",
"testBase64": "ZnJlZA==",
"customFieldHandler": "add-prefix-waldo",
"innerJson": [123, "hello", {"object": true}],
"enums": ["qux", "renamed-bar", "foo", "renamed-baz"],
"simpleGroup": { "renamed-grault": "garply" },
"dependency": { "renamed-foo": "corge" },
"multiMember": "ghi",
"barMember": 789,
"union-type": "renamed-bar",
"pfx.xfp.qux": "fed",
"pfx.baz": {"hello": true},
"pfx.renamed-bar": 321,
"pfx.foo": "this is a long string in order to force multi-line pretty printing",
"flatQux": "cba",
"renamed-flatBaz": {"hello": true},
"flatBar": "abc",
"flatFoo": 123,
"names-can_contain!anything Really": "foo"
})"_kj;
class PrefixAdder: public JsonCodec::Handler<capnp::Text> {
public:
void encode(const JsonCodec& codec, capnp::Text::Reader input, JsonValue::Builder output) const {
output.setString(kj::str("add-prefix-", input));
}
Orphan<capnp::Text> decode(const JsonCodec& codec, JsonValue::Reader input,
Orphanage orphanage) const {
return orphanage.newOrphanCopy(capnp::Text::Reader(input.getString().slice(11)));
}
};
KJ_TEST("rename fields") {
JsonCodec json;
json.handleByAnnotation<TestJsonAnnotations>();
json.setPrettyPrint(true);
PrefixAdder customHandler;
json.addFieldHandler(Schema::from<TestJsonAnnotations>().getFieldByName("customFieldHandler"),
customHandler);
kj::String goldenText;
{
MallocMessageBuilder message;
auto root = message.getRoot<TestJsonAnnotations>();
root.setSomeField("foo");
auto aGroup = root.getAGroup();
aGroup.setFlatFoo(123);
aGroup.setFlatBar("abc");
aGroup.getFlatBaz().setHello(true);
aGroup.getDoubleFlat().setFlatQux("cba");
auto prefixedGroup = root.getPrefixedGroup();
prefixedGroup.setFoo("this is a long string in order to force multi-line pretty printing");
prefixedGroup.setBar(321);
prefixedGroup.getBaz().setHello(true);
prefixedGroup.getMorePrefix().setQux("fed");
auto unionBar = root.getAUnion().initBar();
unionBar.setBarMember(789);
unionBar.setMultiMember("ghi");
root.initDependency().setFoo("corge");
root.initSimpleGroup().setGrault("garply");
root.setEnums({
TestJsonAnnotatedEnum::QUX,
TestJsonAnnotatedEnum::BAR,
TestJsonAnnotatedEnum::FOO,
TestJsonAnnotatedEnum::BAZ
});
auto val = root.initInnerJson();
auto arr = val.initArray(3);
arr[0].setNumber(123);
arr[1].setString("hello");
auto field = arr[2].initObject(1)[0];
field.setName("object");
field.initValue().setBoolean(true);
root.setCustomFieldHandler("waldo");
root.setTestBase64("fred"_kj.asBytes());
root.setTestHex("plugh"_kj.asBytes());
root.getBUnion().setBar(678);
auto encoded = json.encode(root.asReader());
KJ_EXPECT(encoded == GOLDEN_ANNOTATED, encoded);
goldenText = kj::str(root);
}
{
MallocMessageBuilder message;
auto root = message.getRoot<TestJsonAnnotations>();
json.decode(GOLDEN_ANNOTATED, root);
KJ_EXPECT(kj::str(root) == goldenText, root, goldenText);
}
{
// Try parsing in reverse, mostly to test that union tags can come after content.
MallocMessageBuilder message;
auto root = message.getRoot<TestJsonAnnotations>();
json.decode(GOLDEN_ANNOTATED_REVERSE, root);
KJ_EXPECT(kj::str(root) == goldenText, root, goldenText);
}
}
} // namespace
} // namespace _ (private)
} // namespace capnp
c++/src/capnp/compat/json-test.capnp 0 → 100644
View file @ d76ba885
# Copyright (c) 2018 Cloudflare, 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.
@0xc9d405cf4333e4c9;
using Json = import "/capnp/compat/json.capnp";
$import "/capnp/c++.capnp".namespace("capnp");
struct TestJsonAnnotations {
someField @0 :Text $Json.name("names-can_contain!anything Really");
aGroup :group $Json.flatten() {
flatFoo @1 :UInt32;
flatBar @2 :Text;
flatBaz :group $Json.name("renamed-flatBaz") {
hello @3 :Bool;
}
doubleFlat :group $Json.flatten() {
flatQux @4 :Text;
}
}
prefixedGroup :group $Json.flatten(prefix = "pfx.") {
foo @5 :Text;
bar @6 :UInt32 $Json.name("renamed-bar");
baz :group {
hello @7 :Bool;
}
morePrefix :group $Json.flatten(prefix = "xfp.") {
qux @8 :Text;
}
}
aUnion :union $Json.flatten() $Json.discriminator(name = "union-type") {
foo :group $Json.flatten() {
fooMember @9 :Text;
multiMember @10 :UInt32;
}
bar :group $Json.flatten() $Json.name("renamed-bar") {
barMember @11 :UInt32;
multiMember @12 :Text;
}
}
dependency @13 :TestJsonAnnotations2;
# To test that dependencies are loaded even if not flattened.
simpleGroup :group {
# To test that group types are loaded even if not flattened.
grault @14 :Text $Json.name("renamed-grault");
}
enums @15 :List(TestJsonAnnotatedEnum);
innerJson @16 :Json.Value;
customFieldHandler @17 :Text;
testBase64 @18 :Data $Json.base64;
testHex @19 :Data $Json.hex;
bUnion :union $Json.flatten() $Json.discriminator(valueName = "bValue") {
foo @20 :Text;
bar @21 :UInt32 $Json.name("renamed-bar");
}
}
struct TestJsonAnnotations2 {
foo @0 :Text $Json.name("renamed-foo");
cycle @1 :TestJsonAnnotations;
}
enum TestJsonAnnotatedEnum {
foo @0;
bar @1 $Json.name("renamed-bar");
baz @2 $Json.name("renamed-baz");
qux @3;
}
# TODO(now): enums
c++/src/capnp/compat/json.c++
View file @ d76ba885
......@@ -23,37 +23,25 @@
#include <math.h> // for HUGEVAL to check for overflow in strtod
#include <stdlib.h> // strtod
#include <errno.h> // for strtod errors
#include <unordered_map>
#include <capnp/orphan.h>
#include <kj/debug.h>
#include <kj/function.h>
#include <kj/vector.h>
#include <kj/one-of.h>
#include <kj/encoding.h>
#include <kj/map.h>
namespace capnp {
namespace {
struct TypeHash {
size_t operator()(const Type& type) const {
return type.hashCode();
}
};
struct FieldHash {
size_t operator()(const StructSchema::Field& field) const {
return field.getIndex() ^ field.getContainingStruct().getProto().getId();
}
};
} // namespace
struct JsonCodec::Impl {
bool prettyPrint = false;
HasMode hasMode = HasMode::NON_NULL;
size_t maxNestingDepth = 64;
std::unordered_map<Type, HandlerBase*, TypeHash> typeHandlers;
std::unordered_map<StructSchema::Field, HandlerBase*, FieldHash> fieldHandlers;
kj::HashMap<Type, HandlerBase*> typeHandlers;
kj::HashMap<StructSchema::Field, HandlerBase*> fieldHandlers;
kj::HashMap<Type, kj::Maybe<kj::Own<AnnotatedHandler>>> annotatedHandlers;
kj::HashMap<Type, kj::Own<AnnotatedEnumHandler>> annotatedEnumHandlers;
kj::StringTree encodeRaw(JsonValue::Reader value, uint indent, bool& multiline,
bool hasPrefix) const {
......@@ -229,9 +217,8 @@ void JsonCodec::encode(DynamicValue::Reader input, Type type, JsonValue::Builder
// TODO(soon): For interfaces, check for handlers on superclasses, per documentation...
// TODO(soon): For branded types, should we check for handlers on the generic?
// TODO(someday): Allow registering handlers for "all structs", "all lists", etc?
auto iter = impl->typeHandlers.find(type);
if (iter != impl->typeHandlers.end()) {
iter->second->encodeBase(*this, input, output);
KJ_IF_MAYBE(handler, impl->typeHandlers.find(type)) {
(*handler)->encodeBase(*this, input, output);
return;
}
......@@ -377,9 +364,8 @@ void JsonCodec::encode(DynamicValue::Reader input, Type type, JsonValue::Builder
void JsonCodec::encodeField(StructSchema::Field field, DynamicValue::Reader input,
JsonValue::Builder output) const {
auto iter = impl->fieldHandlers.find(field);
if (iter != impl->fieldHandlers.end()) {
iter->second->encodeBase(*this, input, output);
KJ_IF_MAYBE(handler, impl->fieldHandlers.find(field)) {
(*handler)->encodeBase(*this, input, output);
return;
}
......@@ -399,27 +385,29 @@ void JsonCodec::decodeObject(JsonValue::Reader input, StructSchema type, Orphana
KJ_REQUIRE(input.isObject(), "Expected object value");
for (auto field: input.getObject()) {
KJ_IF_MAYBE(fieldSchema, type.findFieldByName(field.getName())) {
auto fieldValue = field.getValue();
auto fieldType = (*fieldSchema).getType();
auto iter = impl->fieldHandlers.find(*fieldSchema);
if (iter != impl->fieldHandlers.end()) {
output.adopt(*fieldSchema, iter->second->decodeBase(*this, fieldValue, fieldType, orphanage));
} else {
output.adopt(*fieldSchema, decode(fieldValue, fieldType, orphanage));
}
decodeField(*fieldSchema, field.getValue(), orphanage, output);
} else {
// Unknown json fields are ignored to allow schema evolution
}
}
}
void JsonCodec::decodeField(StructSchema::Field fieldSchema, JsonValue::Reader fieldValue,
Orphanage orphanage, DynamicStruct::Builder output) const {
auto fieldType = fieldSchema.getType();
KJ_IF_MAYBE(handler, impl->fieldHandlers.find(fieldSchema)) {
output.adopt(fieldSchema, (*handler)->decodeBase(*this, fieldValue, fieldType, orphanage));
} else {
output.adopt(fieldSchema, decode(fieldValue, fieldType, orphanage));
}
}
void JsonCodec::decode(JsonValue::Reader input, DynamicStruct::Builder output) const {
auto type = output.getSchema();
auto iter = impl->typeHandlers.find(type);
if (iter != impl->typeHandlers.end()) {
return iter->second->decodeStructBase(*this, input, output);
KJ_IF_MAYBE(handler, impl->typeHandlers.find(type)) {
return (*handler)->decodeStructBase(*this, input, output);
}
decodeObject(input, type, Orphanage::getForMessageContaining(output), output);
......@@ -427,9 +415,8 @@ void JsonCodec::decode(JsonValue::Reader input, DynamicStruct::Builder output) c
Orphan<DynamicValue> JsonCodec::decode(
JsonValue::Reader input, Type type, Orphanage orphanage) const {
auto iter = impl->typeHandlers.find(type);
if (iter != impl->typeHandlers.end()) {
return iter->second->decodeBase(*this, input, type, orphanage);
KJ_IF_MAYBE(handler, impl->typeHandlers.find(type)) {
return (*handler)->decodeBase(*this, input, type, orphanage);
}
switch(type.which()) {
......@@ -873,13 +860,598 @@ void JsonCodec::HandlerBase::decodeStructBase(
}
void JsonCodec::addTypeHandlerImpl(Type type, HandlerBase& handler) {
impl->typeHandlers[type] = &handler;
impl->typeHandlers.insert(type, &handler);
}
void JsonCodec::addFieldHandlerImpl(StructSchema::Field field, Type type, HandlerBase& handler) {
KJ_REQUIRE(type == field.getType(),
"handler type did not match field type for addFieldHandler()");
impl->fieldHandlers[field] = &handler;
impl->fieldHandlers.insert(field, &handler);
}
// =======================================================================================
static constexpr uint64_t JSON_NAME_ANNOTATION_ID = 0xfa5b1fd61c2e7c3dull;
static constexpr uint64_t JSON_FLATTEN_ANNOTATION_ID = 0x82d3e852af0336bfull;
static constexpr uint64_t JSON_DISCRIMINATOR_ANNOTATION_ID = 0xcfa794e8d19a0162ull;
static constexpr uint64_t JSON_BASE64_ANNOTATION_ID = 0xd7d879450a253e4bull;
static constexpr uint64_t JSON_HEX_ANNOTATION_ID = 0xf061e22f0ae5c7b5ull;
class JsonCodec::Base64Handler final: public JsonCodec::Handler<capnp::Data> {
public:
void encode(const JsonCodec& codec, capnp::Data::Reader input, JsonValue::Builder output) const {
output.setString(kj::encodeBase64(input));
}
Orphan<capnp::Data> decode(const JsonCodec& codec, JsonValue::Reader input,
Orphanage orphanage) const {
return orphanage.newOrphanCopy(capnp::Data::Reader(kj::decodeBase64(input.getString())));
}
};
class JsonCodec::HexHandler final: public JsonCodec::Handler<capnp::Data> {
public:
void encode(const JsonCodec& codec, capnp::Data::Reader input, JsonValue::Builder output) const {
output.setString(kj::encodeHex(input));
}
Orphan<capnp::Data> decode(const JsonCodec& codec, JsonValue::Reader input,
Orphanage orphanage) const {
return orphanage.newOrphanCopy(capnp::Data::Reader(kj::decodeHex(input.getString())));
}
};
class JsonCodec::AnnotatedHandler final: public JsonCodec::Handler<DynamicStruct> {
public:
AnnotatedHandler(JsonCodec& codec, StructSchema schema,
kj::Maybe<json::DiscriminatorOptions::Reader> discriminator,
kj::Maybe<kj::StringPtr> unionDeclName,
kj::Vector<Schema>& dependencies)
: schema(schema) {
auto schemaProto = schema.getProto();
auto typeName = schemaProto.getDisplayName();
if (discriminator == nullptr) {
// There are two cases of unions:
// * Named unions, which are special cases of named groups. In this case, the union may be
// annotated by annotating the field. In this case, we receive a non-null `discriminator`
// as a constructor parameter, and schemaProto.getAnnotations() must be empty because
// it's not possible to annotate a group's type (becaues the type is anonymous).
// * Unnamed unions, of which there can only be one in any particular scope. In this case,
// the parent struct type itself is annotated.
// So if we received `null` as the constructor parameter, check for annotations on the struct
// type.
for (auto anno: schemaProto.getAnnotations()) {
switch (anno.getId()) {
case JSON_DISCRIMINATOR_ANNOTATION_ID:
discriminator = anno.getValue().getStruct().getAs<json::DiscriminatorOptions>();
break;
}
}
}
KJ_IF_MAYBE(d, discriminator) {
if (d->hasName()) {
unionTagName = d->getName();
} else {
unionTagName = unionDeclName;
}
KJ_IF_MAYBE(u, unionTagName) {
fieldsByName.insert(*u, FieldNameInfo {
FieldNameInfo::UNION_TAG, 0, 0, nullptr
});
}
if (d->hasValueName()) {
fieldsByName.insert(d->getValueName(), FieldNameInfo {
FieldNameInfo::UNION_VALUE, 0, 0, nullptr
});
}
}
discriminantOffset = schemaProto.getStruct().getDiscriminantOffset();
fields = KJ_MAP(field, schema.getFields()) {
auto fieldProto = field.getProto();
auto type = field.getType();
auto fieldName = fieldProto.getName();
FieldNameInfo nameInfo;
nameInfo.index = field.getIndex();
nameInfo.type = FieldNameInfo::NORMAL;
nameInfo.prefixLength = 0;
FieldInfo info;
info.name = fieldName;
kj::Maybe<json::DiscriminatorOptions::Reader> subDiscriminator;
bool flattened = false;
for (auto anno: field.getProto().getAnnotations()) {
switch (anno.getId()) {
case JSON_NAME_ANNOTATION_ID:
info.name = anno.getValue().getText();
break;
case JSON_FLATTEN_ANNOTATION_ID:
KJ_REQUIRE(type.isStruct(), "only struct types can be flattened", fieldName, typeName);
flattened = true;
info.prefix = anno.getValue().getStruct().getAs<json::FlattenOptions>().getPrefix();
break;
case JSON_DISCRIMINATOR_ANNOTATION_ID:
KJ_REQUIRE(fieldProto.isGroup(), "only unions can have discriminator");
subDiscriminator = anno.getValue().getStruct().getAs<json::DiscriminatorOptions>();
break;
case JSON_BASE64_ANNOTATION_ID: {
KJ_REQUIRE(field.getType().isData(), "only Data can be marked for base64 encoding");
static Base64Handler handler;
codec.addFieldHandler(field, handler);
break;
}
case JSON_HEX_ANNOTATION_ID: {
KJ_REQUIRE(field.getType().isData(), "only Data can be marked for hex encoding");
static HexHandler handler;
codec.addFieldHandler(field, handler);
break;
}
}
}
if (fieldProto.isGroup()) {
// Load group type handler now, even if not flattened, so that we can pass its
// `subDiscriminator`.
kj::Maybe<kj::StringPtr> subFieldName;
if (flattened) {
// If the group was flattened, then we allow its field name to be used as the
// discriminator name, so that the discriminator doesn't have to explicitly specify a
// name.
subFieldName = fieldName;
}
auto& subHandler = codec.loadAnnotatedHandler(
type.asStruct(), subDiscriminator, subFieldName, dependencies);
if (flattened) {
info.flattenHandler = subHandler;
}
}
bool isUnionMember = fieldProto.getDiscriminantValue() != schema::Field::NO_DISCRIMINANT;
KJ_IF_MAYBE(fh, info.flattenHandler) {
// Set up fieldsByName for each of the child's fields.
for (auto& entry: fh->fieldsByName) {
kj::StringPtr flattenedName;
kj::String ownName;
if (info.prefix.size() > 0) {
ownName = kj::str(info.prefix, entry.key);
flattenedName = ownName;
} else {
flattenedName = entry.key;
}
fieldsByName.upsert(flattenedName, FieldNameInfo {
isUnionMember ? FieldNameInfo::FLATTENED_FROM_UNION : FieldNameInfo::FLATTENED,
field.getIndex(), (uint)info.prefix.size(), kj::mv(ownName)
}, [&](FieldNameInfo& existing, FieldNameInfo&& replacement) {
KJ_REQUIRE(existing.type == FieldNameInfo::FLATTENED_FROM_UNION &&
replacement.type == FieldNameInfo::FLATTENED_FROM_UNION,
"flattened members have the same name and are not mutually exclusive");
});
}
}
info.nameForDiscriminant = info.name;
if (!flattened) {
bool isUnionWithValueName = false;
if (isUnionMember) {
KJ_IF_MAYBE(d, discriminator) {
if (d->hasValueName()) {
info.name = d->getValueName();
isUnionWithValueName = true;
}
}
}
if (!isUnionWithValueName) {
fieldsByName.insert(info.name, kj::mv(nameInfo));
}
}
if (isUnionMember) {
unionTagValues.insert(info.nameForDiscriminant, field);
}
// Look for dependencies that we need to add.
while (type.isList()) type = type.asList().getElementType();
if (codec.impl->typeHandlers.find(type) == nullptr) {
switch (type.which()) {
case schema::Type::STRUCT:
dependencies.add(type.asStruct());
break;
case schema::Type::ENUM:
dependencies.add(type.asEnum());
break;
case schema::Type::INTERFACE:
dependencies.add(type.asInterface());
break;
default:
break;
}
}
return info;
};
}
const StructSchema schema;
void encode(const JsonCodec& codec, DynamicStruct::Reader input,
JsonValue::Builder output) const override {
kj::Vector<FlattenedField> flattenedFields;
gatherForEncode(codec, input, nullptr, nullptr, flattenedFields);
auto outs = output.initObject(flattenedFields.size());
for (auto i: kj::indices(flattenedFields)) {
auto& in = flattenedFields[i];
auto out = outs[i];
out.setName(in.name);
KJ_SWITCH_ONEOF(in.type) {
KJ_CASE_ONEOF(type, Type) {
codec.encode(in.value, type, out.initValue());
}
KJ_CASE_ONEOF(field, StructSchema::Field) {
codec.encodeField(field, in.value, out.initValue());
}
}
}
}
void decode(const JsonCodec& codec, JsonValue::Reader input,
DynamicStruct::Builder output) const override {
KJ_REQUIRE(input.isObject());
kj::HashMap<const void*, StructSchema::Field> unionsSeen;
kj::Vector<JsonValue::Field::Reader> retries;
for (auto field: input.getObject()) {
if (!decodeField(codec, field.getName(), field.getValue(), output, unionsSeen)) {
retries.add(field);
}
}
while (!retries.empty()) {
auto retriesCopy = kj::mv(retries);
KJ_ASSERT(retries.empty());
for (auto field: retriesCopy) {
if (!decodeField(codec, field.getName(), field.getValue(), output, unionsSeen)) {
retries.add(field);
}
}
if (retries.size() == retriesCopy.size()) {
// We made no progress in this iteration. Give up on the remaining fields.
break;
}
}
}
private:
struct FieldInfo {
kj::StringPtr name;
kj::StringPtr nameForDiscriminant;
kj::Maybe<const AnnotatedHandler&> flattenHandler;
kj::StringPtr prefix;
};
kj::Array<FieldInfo> fields;
// Maps field index -> info about the field
struct FieldNameInfo {
enum {
NORMAL,
// This is a normal field with the given `index`.
FLATTENED,
// This is a field of a flattened inner struct or group (that is not in a union). `index`
// is the field index of the particular struct/group field.
UNION_TAG,
// The parent struct is a flattened union, and this field is the discriminant tag. It is a
// string field whose name determines the union type. `index` is not used.
FLATTENED_FROM_UNION,
// The parent struct is a flattened union, and some of the union's members are flattened
// structs or groups, and this field is possibly a member of one or more of them. `index`
// is not used, because it's possible that the same field name appears in multiple variants.
// Intsead, the parser must find the union tag, and then can descend and attempt to parse
// the field in the context of whichever variant is selected.
UNION_VALUE
// This field is the value of a discriminated union that has `valueName` set.
} type;
uint index;
// For `NORMAL` and `FLATTENED`, the index of the field in schema.getFields().
uint prefixLength;
kj::String ownName;
};
kj::HashMap<kj::StringPtr, FieldNameInfo> fieldsByName;
// Maps JSON names to info needed to parse them.
kj::HashMap<kj::StringPtr, StructSchema::Field> unionTagValues;
// If the parent struct is a flattened union, it has a tag field which is a string with one of
// these values. The map maps to the union member to set.
kj::Maybe<kj::StringPtr> unionTagName;
// If the parent struct is a flattened union, the name of the "tag" field.
uint discriminantOffset;
// Shortcut for schema.getProto().getStruct().getDiscriminantOffset(), used in a hack to identify
// which unions have been seen.
struct FlattenedField {
kj::String ownName;
kj::StringPtr name;
kj::OneOf<StructSchema::Field, Type> type;
DynamicValue::Reader value;
FlattenedField(kj::StringPtr prefix, kj::StringPtr name,
kj::OneOf<StructSchema::Field, Type> type, DynamicValue::Reader value)
: ownName(prefix.size() > 0 ? kj::str(prefix, name) : nullptr),
name(prefix.size() > 0 ? ownName : name),
type(type), value(value) {}
};
void gatherForEncode(const JsonCodec& codec, DynamicValue::Reader input,
kj::StringPtr prefix, kj::StringPtr morePrefix,
kj::Vector<FlattenedField>& flattenedFields) const {
kj::String ownPrefix;
if (morePrefix.size() > 0) {
if (prefix.size() > 0) {
ownPrefix = kj::str(prefix, morePrefix);
prefix = ownPrefix;
} else {
prefix = morePrefix;
}
}
auto reader = input.as<DynamicStruct>();
auto schema = reader.getSchema();
for (auto field: schema.getNonUnionFields()) {
auto& info = fields[field.getIndex()];
if (!reader.has(field, codec.impl->hasMode)) {
// skip
} else KJ_IF_MAYBE(handler, info.flattenHandler) {
handler->gatherForEncode(codec, reader.get(field), prefix, info.prefix, flattenedFields);
} else {
flattenedFields.add(FlattenedField {
prefix, info.name, field, reader.get(field) });
}
}
KJ_IF_MAYBE(which, reader.which()) {
auto& info = fields[which->getIndex()];
KJ_IF_MAYBE(tag, unionTagName) {
flattenedFields.add(FlattenedField {
prefix, *tag, Type(schema::Type::TEXT), Text::Reader(info.nameForDiscriminant) });
}
KJ_IF_MAYBE(handler, info.flattenHandler) {
handler->gatherForEncode(codec, reader.get(*which), prefix, info.prefix, flattenedFields);
} else {
flattenedFields.add(FlattenedField {
prefix, info.name, which->getType(), reader.get(*which) });
}
}
}
bool decodeField(const JsonCodec& codec, kj::StringPtr name, JsonValue::Reader value,
DynamicStruct::Builder output,
kj::HashMap<const void*, StructSchema::Field>& unionsSeen) const {
KJ_ASSERT(output.getSchema() == schema);
KJ_IF_MAYBE(info, fieldsByName.find(name)) {
switch (info->type) {
case FieldNameInfo::NORMAL: {
auto field = output.getSchema().getFields()[info->index];
codec.decodeField(field, value, Orphanage::getForMessageContaining(output), output);
return true;
}
case FieldNameInfo::FLATTENED:
return KJ_ASSERT_NONNULL(fields[info->index].flattenHandler)
.decodeField(codec, name.slice(info->prefixLength), value,
output.get(output.getSchema().getFields()[info->index]).as<DynamicStruct>(),
unionsSeen);
case FieldNameInfo::UNION_TAG: {
KJ_REQUIRE(value.isString(), "Expected string value.");
// Mark that we've seen a union tag for this struct.
const void* ptr = getUnionInstanceIdentifier(output);
KJ_IF_MAYBE(field, unionTagValues.find(value.getString())) {
unionsSeen.insert(ptr, *field);
}
return true;
}
case FieldNameInfo::FLATTENED_FROM_UNION: {
const void* ptr = getUnionInstanceIdentifier(output);
KJ_IF_MAYBE(variant, unionsSeen.find(ptr)) {
bool alreadyInitialized = output.which()
.map([&](auto f) { return f == *variant; })
.orDefault(false);
auto child = alreadyInitialized ? output.get(*variant) : output.init(*variant);
return KJ_ASSERT_NONNULL(fields[variant->getIndex()].flattenHandler)
.decodeField(codec, name.slice(info->prefixLength), value,
child.as<DynamicStruct>(), unionsSeen);
} else {
// We haven't seen the union tag yet, so we can't parse this field yet. Try again later.
return false;
}
}
case FieldNameInfo::UNION_VALUE: {
const void* ptr = getUnionInstanceIdentifier(output);
KJ_IF_MAYBE(variant, unionsSeen.find(ptr)) {
codec.decodeField(*variant, value, Orphanage::getForMessageContaining(output), output);
return true;
} else {
// We haven't seen the union tag yet, so we can't parse this field yet. Try again later.
return false;
}
}
}
KJ_UNREACHABLE;
} else {
// Ignore undefined field.
return true;
}
}
const void* getUnionInstanceIdentifier(DynamicStruct::Builder obj) const {
// Gets a value uniquely identifying an instance of a union.
// HACK: We return a poniter to the union's discriminant within the underlying buffer.
return reinterpret_cast<const uint16_t*>(
AnyStruct::Reader(obj.asReader()).getDataSection().begin()) + discriminantOffset;
}
};
class JsonCodec::AnnotatedEnumHandler final: public JsonCodec::Handler<DynamicEnum> {
public:
AnnotatedEnumHandler(EnumSchema schema): schema(schema) {
auto enumerants = schema.getEnumerants();
auto builder = kj::heapArrayBuilder<kj::StringPtr>(enumerants.size());
for (auto e: enumerants) {
auto proto = e.getProto();
kj::StringPtr name = proto.getName();
for (auto anno: proto.getAnnotations()) {
switch (anno.getId()) {
case JSON_NAME_ANNOTATION_ID:
name = anno.getValue().getText();
break;
}
}
builder.add(name);
nameToValue.insert(name, e.getIndex());
}
valueToName = builder.finish();
}
void encode(const JsonCodec& codec, DynamicEnum input, JsonValue::Builder output) const override {
KJ_IF_MAYBE(e, input.getEnumerant()) {
KJ_ASSERT(e->getIndex() < valueToName.size());
output.setString(valueToName[e->getIndex()]);
} else {
output.setNumber(input.getRaw());
}
}
DynamicEnum decode(const JsonCodec& codec, JsonValue::Reader input) const override {
if (input.isNumber()) {
return DynamicEnum(schema, static_cast<uint16_t>(input.getNumber()));
} else {
uint16_t val = KJ_REQUIRE_NONNULL(nameToValue.find(input.getString()),
"invalid enum value", input.getString());
return DynamicEnum(schema.getEnumerants()[val]);
}
}
private:
EnumSchema schema;
kj::Array<kj::StringPtr> valueToName;
kj::HashMap<kj::StringPtr, uint16_t> nameToValue;
};
class JsonCodec::JsonValueHandler final: public JsonCodec::Handler<DynamicStruct> {
public:
void encode(const JsonCodec& codec, DynamicStruct::Reader input,
JsonValue::Builder output) const override {
#if _MSC_VER
// TODO(msvc): Hack to work around missing AnyStruct::Builder constructor on MSVC.
rawCopy(input, toDynamic(output));
#else
rawCopy(input, kj::mv(output));
#endif
}
void decode(const JsonCodec& codec, JsonValue::Reader input,
DynamicStruct::Builder output) const override {
rawCopy(input, kj::mv(output));
}
private:
void rawCopy(AnyStruct::Reader input, AnyStruct::Builder output) const {
// HACK: Manually copy using AnyStruct, so that if JsonValue's definition changes, this code
// doesn't need to be updated. However, note that if JsonValue ever adds new fields that
// change its size, and the input struct is a newer version than the output, we may lose
// the new fields. Technically the "correct" thing to do would be to allocate the output
// struct to be exactly the same size as the input, but JsonCodec's Handler interface is
// not designed to allow that -- it passes in an already-allocated builder. Oops.
auto dataIn = input.getDataSection();
auto dataOut = output.getDataSection();
memcpy(dataOut.begin(), dataIn.begin(), kj::min(dataOut.size(), dataIn.size()));
auto ptrIn = input.getPointerSection();
auto ptrOut = output.getPointerSection();
for (auto i: kj::zeroTo(kj::min(ptrIn.size(), ptrOut.size()))) {
ptrOut[i].set(ptrIn[i]);
}
}
};
JsonCodec::AnnotatedHandler& JsonCodec::loadAnnotatedHandler(
StructSchema schema, kj::Maybe<json::DiscriminatorOptions::Reader> discriminator,
kj::Maybe<kj::StringPtr> unionDeclName, kj::Vector<Schema>& dependencies) {
auto& entry = impl->annotatedHandlers.upsert(schema, nullptr,
[&](kj::Maybe<kj::Own<AnnotatedHandler>>& existing, auto dummy) {
KJ_ASSERT(existing != nullptr,
"cyclic JSON flattening detected", schema.getProto().getDisplayName());
});
KJ_IF_MAYBE(v, entry.value) {
// Already exists.
return **v;
} else {
// Not seen before.
auto newHandler = kj::heap<AnnotatedHandler>(
*this, schema, discriminator, unionDeclName, dependencies);
auto& result = *newHandler;
// Map may have changed, so we have to look up again.
KJ_ASSERT_NONNULL(impl->annotatedHandlers.find(schema)) = kj::mv(newHandler);
addTypeHandler(schema, result);
return result;
};
}
void JsonCodec::handleByAnnotation(Schema schema) {
switch (schema.getProto().which()) {
case schema::Node::STRUCT: {
if (schema.getProto().getId() == capnp::typeId<JsonValue>()) {
// Special handler for JsonValue.
static JsonValueHandler GLOBAL_HANDLER;
addTypeHandler(schema.asStruct(), GLOBAL_HANDLER);
} else {
kj::Vector<Schema> dependencies;
loadAnnotatedHandler(schema.asStruct(), nullptr, nullptr, dependencies);
for (auto dep: dependencies) {
handleByAnnotation(dep);
}
}
break;
}
case schema::Node::ENUM: {
auto enumSchema = schema.asEnum();
impl->annotatedEnumHandlers.findOrCreate(enumSchema, [&]() {
auto handler = kj::heap<AnnotatedEnumHandler>(enumSchema);
addTypeHandler(enumSchema, *handler);
return kj::HashMap<Type, kj::Own<AnnotatedEnumHandler>>::Entry {
enumSchema, kj::mv(handler) };
});
break;
}
default:
break;
}
}
} // namespace capnp
c++/src/capnp/compat/json.capnp
View file @ d76ba885
......@@ -21,15 +21,15 @@
@0x8ef99297a43a5e34;
$import "/capnp/c++.capnp".namespace("capnp");
$import "/capnp/c++.capnp".namespace("capnp::json");
struct JsonValue {
struct Value {
union {
null @0 :Void;
boolean @1 :Bool;
number @2 :Float64;
string @3 :Text;
array @4 :List(JsonValue);
array @4 :List(Value);
object @5 :List(Field);
# Standard JSON values.
......@@ -48,11 +48,65 @@ struct JsonValue {
struct Field {
name @0 :Text;
value @1 :JsonValue;
value @1 :Value;
}
struct Call {
function @0 :Text;
params @1 :List(JsonValue);
params @1 :List(Value);
}
}
# ========================================================================================
# Annotations to control parsing. Typical usage:
#
# using Json = import "/capnp/compat/json.capnp";
#
# And then later on:
#
# myField @0 :Text $Json.name("my_field");
annotation name @0xfa5b1fd61c2e7c3d (field, enumerant, method, group, union): Text;
# Define an alternative name to use when encoding the given item in JSON. This can be used, for
# example, to use snake_case names where needed, even though Cap'n Proto uses strictly camelCase.
#
# (However, because JSON is derived from JavaScript, you *should* use camelCase names when
# defining JSON-based APIs. But, when supporting a pre-existing API you may not have a choice.)
annotation flatten @0x82d3e852af0336bf (field, group, union): FlattenOptions;
# Specifies that an aggregate field should be flattened into its parent.
#
# In order to flatten a member of a union, the union (or, for an anonymous union, the parent
# struct type) must have the $jsonDiscriminator annotation.
#
# TODO(someday): Maybe support "flattening" a List(Value.Field) as a way to support unknown JSON
# fields?
struct FlattenOptions {
prefix @0 :Text = "";
# Optional: Adds the given prefix to flattened field names.
}
annotation discriminator @0xcfa794e8d19a0162 (struct, union): DiscriminatorOptions;
# Specifies that a union's variant will be decided not by which fields are present, but instead
# by a special discriminator field. The value of the discriminator field is a string naming which
# variant is active. This allows the members of the union to have the $jsonFlatten annotation, or
# to all have the same name.
struct DiscriminatorOptions {
name @0 :Text;
# The name of the discriminator field. Defaults to matching the name of the union.
valueName @1 :Text;
# If non-null, specifies that the union's value shall have the given field name, rather than the
# value's name. In this case the union's variant can only be determined by looking at the
# discriminant field, not by inspecting which value field is present.
#
# It is an error to use `valueName` while also declaring some variants as $flatten.
}
annotation base64 @0xd7d879450a253e4b (field): Void;
# Place on a field of type `Data` to indicate that its JSON representation is a Base64 string.
annotation hex @0xf061e22f0ae5c7b5 (field): Void;
# Place on a field of type `Data` to indicate that its JSON representation is a hex string.
c++/src/capnp/compat/json.capnp.c++
View file @ d76ba885
......@@ -5,28 +5,27 @@
namespace capnp {
namespace schemas {
static const ::capnp::_::AlignedData<138> b_8825ffaa852cda72 = {
static const ::capnp::_::AlignedData<137> b_a3fa7845f919dd83 = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
114, 218, 44, 133, 170, 255, 37, 136,
131, 221, 25, 249, 69, 120, 250, 163,
24, 0, 0, 0, 1, 0, 2, 0,
52, 94, 58, 164, 151, 146, 249, 142,
1, 0, 7, 0, 0, 0, 7, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 18, 1, 0, 0,
37, 0, 0, 0, 39, 0, 0, 0,
21, 0, 0, 0, 242, 0, 0, 0,
33, 0, 0, 0, 39, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
57, 0, 0, 0, 143, 1, 0, 0,
53, 0, 0, 0, 143, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
74, 115, 111, 110, 86, 97, 108, 117,
101, 0, 0, 0, 0, 0, 0, 0,
86, 97, 108, 117, 101, 0, 0, 0,
8, 0, 0, 0, 1, 0, 1, 0,
204, 55, 169, 83, 216, 85, 120, 194,
223, 157, 214, 53, 231, 38, 16, 227,
9, 0, 0, 0, 50, 0, 0, 0,
96, 187, 212, 61, 21, 132, 191, 155,
72, 61, 201, 161, 236, 246, 217, 160,
5, 0, 0, 0, 42, 0, 0, 0,
70, 105, 101, 108, 100, 0, 0, 0,
67, 97, 108, 108, 0, 0, 0, 0,
......@@ -118,7 +117,7 @@ static const ::capnp::_::AlignedData<138> b_8825ffaa852cda72 = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0, 1, 0,
16, 0, 0, 0, 0, 0, 0, 0,
114, 218, 44, 133, 170, 255, 37, 136,
131, 221, 25, 249, 69, 120, 250, 163,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
14, 0, 0, 0, 0, 0, 0, 0,
......@@ -130,7 +129,7 @@ static const ::capnp::_::AlignedData<138> b_8825ffaa852cda72 = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0, 1, 0,
16, 0, 0, 0, 0, 0, 0, 0,
204, 55, 169, 83, 216, 85, 120, 194,
223, 157, 214, 53, 231, 38, 16, 227,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
14, 0, 0, 0, 0, 0, 0, 0,
......@@ -138,35 +137,35 @@ static const ::capnp::_::AlignedData<138> b_8825ffaa852cda72 = {
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 108, 108, 0, 0, 0, 0,
16, 0, 0, 0, 0, 0, 0, 0,
96, 187, 212, 61, 21, 132, 191, 155,
72, 61, 201, 161, 236, 246, 217, 160,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
16, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_8825ffaa852cda72 = b_8825ffaa852cda72.words;
::capnp::word const* const bp_a3fa7845f919dd83 = b_a3fa7845f919dd83.words;
#if !CAPNP_LITE
static const ::capnp::_::RawSchema* const d_8825ffaa852cda72[] = {
&s_8825ffaa852cda72,
&s_9bbf84153dd4bb60,
&s_c27855d853a937cc,
static const ::capnp::_::RawSchema* const d_a3fa7845f919dd83[] = {
&s_a0d9f6eca1c93d48,
&s_a3fa7845f919dd83,
&s_e31026e735d69ddf,
};
static const uint16_t m_8825ffaa852cda72[] = {4, 1, 6, 0, 2, 5, 3};
static const uint16_t i_8825ffaa852cda72[] = {0, 1, 2, 3, 4, 5, 6};
const ::capnp::_::RawSchema s_8825ffaa852cda72 = {
0x8825ffaa852cda72, b_8825ffaa852cda72.words, 138, d_8825ffaa852cda72, m_8825ffaa852cda72,
3, 7, i_8825ffaa852cda72, nullptr, nullptr, { &s_8825ffaa852cda72, nullptr, nullptr, 0, 0, nullptr }
static const uint16_t m_a3fa7845f919dd83[] = {4, 1, 6, 0, 2, 5, 3};
static const uint16_t i_a3fa7845f919dd83[] = {0, 1, 2, 3, 4, 5, 6};
const ::capnp::_::RawSchema s_a3fa7845f919dd83 = {
0xa3fa7845f919dd83, b_a3fa7845f919dd83.words, 137, d_a3fa7845f919dd83, m_a3fa7845f919dd83,
3, 7, i_a3fa7845f919dd83, nullptr, nullptr, { &s_a3fa7845f919dd83, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<49> b_c27855d853a937cc = {
static const ::capnp::_::AlignedData<49> b_e31026e735d69ddf = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
204, 55, 169, 83, 216, 85, 120, 194,
34, 0, 0, 0, 1, 0, 0, 0,
114, 218, 44, 133, 170, 255, 37, 136,
223, 157, 214, 53, 231, 38, 16, 227,
30, 0, 0, 0, 1, 0, 0, 0,
131, 221, 25, 249, 69, 120, 250, 163,
2, 0, 7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 66, 1, 0, 0,
21, 0, 0, 0, 34, 1, 0, 0,
37, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
33, 0, 0, 0, 119, 0, 0, 0,
......@@ -175,8 +174,8 @@ static const ::capnp::_::AlignedData<49> b_c27855d853a937cc = {
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
74, 115, 111, 110, 86, 97, 108, 117,
101, 46, 70, 105, 101, 108, 100, 0,
86, 97, 108, 117, 101, 46, 70, 105,
101, 108, 100, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0,
8, 0, 0, 0, 3, 0, 4, 0,
0, 0, 0, 0, 0, 0, 0, 0,
......@@ -203,33 +202,33 @@ static const ::capnp::_::AlignedData<49> b_c27855d853a937cc = {
0, 0, 0, 0, 0, 0, 0, 0,
118, 97, 108, 117, 101, 0, 0, 0,
16, 0, 0, 0, 0, 0, 0, 0,
114, 218, 44, 133, 170, 255, 37, 136,
131, 221, 25, 249, 69, 120, 250, 163,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
16, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_c27855d853a937cc = b_c27855d853a937cc.words;
::capnp::word const* const bp_e31026e735d69ddf = b_e31026e735d69ddf.words;
#if !CAPNP_LITE
static const ::capnp::_::RawSchema* const d_c27855d853a937cc[] = {
&s_8825ffaa852cda72,
static const ::capnp::_::RawSchema* const d_e31026e735d69ddf[] = {
&s_a3fa7845f919dd83,
};
static const uint16_t m_c27855d853a937cc[] = {0, 1};
static const uint16_t i_c27855d853a937cc[] = {0, 1};
const ::capnp::_::RawSchema s_c27855d853a937cc = {
0xc27855d853a937cc, b_c27855d853a937cc.words, 49, d_c27855d853a937cc, m_c27855d853a937cc,
1, 2, i_c27855d853a937cc, nullptr, nullptr, { &s_c27855d853a937cc, nullptr, nullptr, 0, 0, nullptr }
static const uint16_t m_e31026e735d69ddf[] = {0, 1};
static const uint16_t i_e31026e735d69ddf[] = {0, 1};
const ::capnp::_::RawSchema s_e31026e735d69ddf = {
0xe31026e735d69ddf, b_e31026e735d69ddf.words, 49, d_e31026e735d69ddf, m_e31026e735d69ddf,
1, 2, i_e31026e735d69ddf, nullptr, nullptr, { &s_e31026e735d69ddf, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<54> b_9bbf84153dd4bb60 = {
static const ::capnp::_::AlignedData<54> b_a0d9f6eca1c93d48 = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
96, 187, 212, 61, 21, 132, 191, 155,
34, 0, 0, 0, 1, 0, 0, 0,
114, 218, 44, 133, 170, 255, 37, 136,
72, 61, 201, 161, 236, 246, 217, 160,
30, 0, 0, 0, 1, 0, 0, 0,
131, 221, 25, 249, 69, 120, 250, 163,
2, 0, 7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 58, 1, 0, 0,
21, 0, 0, 0, 26, 1, 0, 0,
37, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
33, 0, 0, 0, 119, 0, 0, 0,
......@@ -238,8 +237,8 @@ static const ::capnp::_::AlignedData<54> b_9bbf84153dd4bb60 = {
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
74, 115, 111, 110, 86, 97, 108, 117,
101, 46, 67, 97, 108, 108, 0, 0,
86, 97, 108, 117, 101, 46, 67, 97,
108, 108, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0,
8, 0, 0, 0, 3, 0, 4, 0,
0, 0, 0, 0, 0, 0, 0, 0,
......@@ -271,23 +270,282 @@ static const ::capnp::_::AlignedData<54> b_9bbf84153dd4bb60 = {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0, 1, 0,
16, 0, 0, 0, 0, 0, 0, 0,
114, 218, 44, 133, 170, 255, 37, 136,
131, 221, 25, 249, 69, 120, 250, 163,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
14, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_9bbf84153dd4bb60 = b_9bbf84153dd4bb60.words;
::capnp::word const* const bp_a0d9f6eca1c93d48 = b_a0d9f6eca1c93d48.words;
#if !CAPNP_LITE
static const ::capnp::_::RawSchema* const d_a0d9f6eca1c93d48[] = {
&s_a3fa7845f919dd83,
};
static const uint16_t m_a0d9f6eca1c93d48[] = {0, 1};
static const uint16_t i_a0d9f6eca1c93d48[] = {0, 1};
const ::capnp::_::RawSchema s_a0d9f6eca1c93d48 = {
0xa0d9f6eca1c93d48, b_a0d9f6eca1c93d48.words, 54, d_a0d9f6eca1c93d48, m_a0d9f6eca1c93d48,
1, 2, i_a0d9f6eca1c93d48, nullptr, nullptr, { &s_a0d9f6eca1c93d48, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<21> b_fa5b1fd61c2e7c3d = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
61, 124, 46, 28, 214, 31, 91, 250,
24, 0, 0, 0, 5, 0, 232, 2,
52, 94, 58, 164, 151, 146, 249, 142,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 234, 0, 0, 0,
33, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
28, 0, 0, 0, 3, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
110, 97, 109, 101, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0,
12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_fa5b1fd61c2e7c3d = b_fa5b1fd61c2e7c3d.words;
#if !CAPNP_LITE
const ::capnp::_::RawSchema s_fa5b1fd61c2e7c3d = {
0xfa5b1fd61c2e7c3d, b_fa5b1fd61c2e7c3d.words, 21, nullptr, nullptr,
0, 0, nullptr, nullptr, nullptr, { &s_fa5b1fd61c2e7c3d, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<21> b_82d3e852af0336bf = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
191, 54, 3, 175, 82, 232, 211, 130,
24, 0, 0, 0, 5, 0, 224, 0,
52, 94, 58, 164, 151, 146, 249, 142,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 2, 1, 0, 0,
33, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
28, 0, 0, 0, 3, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
102, 108, 97, 116, 116, 101, 110, 0,
0, 0, 0, 0, 1, 0, 1, 0,
16, 0, 0, 0, 0, 0, 0, 0,
97, 234, 194, 123, 37, 19, 223, 196,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_82d3e852af0336bf = b_82d3e852af0336bf.words;
#if !CAPNP_LITE
const ::capnp::_::RawSchema s_82d3e852af0336bf = {
0x82d3e852af0336bf, b_82d3e852af0336bf.words, 21, nullptr, nullptr,
0, 0, nullptr, nullptr, nullptr, { &s_82d3e852af0336bf, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<35> b_c4df13257bc2ea61 = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
97, 234, 194, 123, 37, 19, 223, 196,
24, 0, 0, 0, 1, 0, 0, 0,
52, 94, 58, 164, 151, 146, 249, 142,
1, 0, 7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 58, 1, 0, 0,
37, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
33, 0, 0, 0, 63, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
70, 108, 97, 116, 116, 101, 110, 79,
112, 116, 105, 111, 110, 115, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0,
4, 0, 0, 0, 3, 0, 4, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0, 0, 0,
13, 0, 0, 0, 58, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
8, 0, 0, 0, 3, 0, 1, 0,
20, 0, 0, 0, 2, 0, 1, 0,
112, 114, 101, 102, 105, 120, 0, 0,
12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 10, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_c4df13257bc2ea61 = b_c4df13257bc2ea61.words;
#if !CAPNP_LITE
static const ::capnp::_::RawSchema* const d_9bbf84153dd4bb60[] = {
&s_8825ffaa852cda72,
static const uint16_t m_c4df13257bc2ea61[] = {0};
static const uint16_t i_c4df13257bc2ea61[] = {0};
const ::capnp::_::RawSchema s_c4df13257bc2ea61 = {
0xc4df13257bc2ea61, b_c4df13257bc2ea61.words, 35, nullptr, m_c4df13257bc2ea61,
0, 1, i_c4df13257bc2ea61, nullptr, nullptr, { &s_c4df13257bc2ea61, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<22> b_cfa794e8d19a0162 = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
98, 1, 154, 209, 232, 148, 167, 207,
24, 0, 0, 0, 5, 0, 80, 0,
52, 94, 58, 164, 151, 146, 249, 142,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 50, 1, 0, 0,
37, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
32, 0, 0, 0, 3, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
100, 105, 115, 99, 114, 105, 109, 105,
110, 97, 116, 111, 114, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0,
16, 0, 0, 0, 0, 0, 0, 0,
25, 83, 62, 41, 12, 194, 248, 194,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
static const uint16_t m_9bbf84153dd4bb60[] = {0, 1};
static const uint16_t i_9bbf84153dd4bb60[] = {0, 1};
const ::capnp::_::RawSchema s_9bbf84153dd4bb60 = {
0x9bbf84153dd4bb60, b_9bbf84153dd4bb60.words, 54, d_9bbf84153dd4bb60, m_9bbf84153dd4bb60,
1, 2, i_9bbf84153dd4bb60, nullptr, nullptr, { &s_9bbf84153dd4bb60, nullptr, nullptr, 0, 0, nullptr }
::capnp::word const* const bp_cfa794e8d19a0162 = b_cfa794e8d19a0162.words;
#if !CAPNP_LITE
const ::capnp::_::RawSchema s_cfa794e8d19a0162 = {
0xcfa794e8d19a0162, b_cfa794e8d19a0162.words, 22, nullptr, nullptr,
0, 0, nullptr, nullptr, nullptr, { &s_cfa794e8d19a0162, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<51> b_c2f8c20c293e5319 = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
25, 83, 62, 41, 12, 194, 248, 194,
24, 0, 0, 0, 1, 0, 0, 0,
52, 94, 58, 164, 151, 146, 249, 142,
2, 0, 7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 106, 1, 0, 0,
41, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
37, 0, 0, 0, 119, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
68, 105, 115, 99, 114, 105, 109, 105,
110, 97, 116, 111, 114, 79, 112, 116,
105, 111, 110, 115, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0,
8, 0, 0, 0, 3, 0, 4, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
41, 0, 0, 0, 42, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
36, 0, 0, 0, 3, 0, 1, 0,
48, 0, 0, 0, 2, 0, 1, 0,
1, 0, 0, 0, 1, 0, 0, 0,
0, 0, 1, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
45, 0, 0, 0, 82, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
44, 0, 0, 0, 3, 0, 1, 0,
56, 0, 0, 0, 2, 0, 1, 0,
110, 97, 109, 101, 0, 0, 0, 0,
12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
118, 97, 108, 117, 101, 78, 97, 109,
101, 0, 0, 0, 0, 0, 0, 0,
12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
12, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_c2f8c20c293e5319 = b_c2f8c20c293e5319.words;
#if !CAPNP_LITE
static const uint16_t m_c2f8c20c293e5319[] = {0, 1};
static const uint16_t i_c2f8c20c293e5319[] = {0, 1};
const ::capnp::_::RawSchema s_c2f8c20c293e5319 = {
0xc2f8c20c293e5319, b_c2f8c20c293e5319.words, 51, nullptr, m_c2f8c20c293e5319,
0, 2, i_c2f8c20c293e5319, nullptr, nullptr, { &s_c2f8c20c293e5319, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<21> b_d7d879450a253e4b = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
75, 62, 37, 10, 69, 121, 216, 215,
24, 0, 0, 0, 5, 0, 32, 0,
52, 94, 58, 164, 151, 146, 249, 142,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 250, 0, 0, 0,
33, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
28, 0, 0, 0, 3, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
98, 97, 115, 101, 54, 52, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_d7d879450a253e4b = b_d7d879450a253e4b.words;
#if !CAPNP_LITE
const ::capnp::_::RawSchema s_d7d879450a253e4b = {
0xd7d879450a253e4b, b_d7d879450a253e4b.words, 21, nullptr, nullptr,
0, 0, nullptr, nullptr, nullptr, { &s_d7d879450a253e4b, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
static const ::capnp::_::AlignedData<21> b_f061e22f0ae5c7b5 = {
{ 0, 0, 0, 0, 5, 0, 6, 0,
181, 199, 229, 10, 47, 226, 97, 240,
24, 0, 0, 0, 5, 0, 32, 0,
52, 94, 58, 164, 151, 146, 249, 142,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
21, 0, 0, 0, 226, 0, 0, 0,
33, 0, 0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
28, 0, 0, 0, 3, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
99, 97, 112, 110, 112, 47, 99, 111,
109, 112, 97, 116, 47, 106, 115, 111,
110, 46, 99, 97, 112, 110, 112, 58,
104, 101, 120, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, }
};
::capnp::word const* const bp_f061e22f0ae5c7b5 = b_f061e22f0ae5c7b5.words;
#if !CAPNP_LITE
const ::capnp::_::RawSchema s_f061e22f0ae5c7b5 = {
0xf061e22f0ae5c7b5, b_f061e22f0ae5c7b5.words, 21, nullptr, nullptr,
0, 0, nullptr, nullptr, nullptr, { &s_f061e22f0ae5c7b5, nullptr, nullptr, 0, 0, nullptr }
};
#endif // !CAPNP_LITE
} // namespace schemas
......@@ -296,31 +554,49 @@ const ::capnp::_::RawSchema s_9bbf84153dd4bb60 = {
// =======================================================================================
namespace capnp {
namespace json {
// Value
constexpr uint16_t Value::_capnpPrivate::dataWordSize;
constexpr uint16_t Value::_capnpPrivate::pointerCount;
#if !CAPNP_LITE
constexpr ::capnp::Kind Value::_capnpPrivate::kind;
constexpr ::capnp::_::RawSchema const* Value::_capnpPrivate::schema;
#endif // !CAPNP_LITE
// JsonValue
constexpr uint16_t JsonValue::_capnpPrivate::dataWordSize;
constexpr uint16_t JsonValue::_capnpPrivate::pointerCount;
// Value::Field
constexpr uint16_t Value::Field::_capnpPrivate::dataWordSize;
constexpr uint16_t Value::Field::_capnpPrivate::pointerCount;
#if !CAPNP_LITE
constexpr ::capnp::Kind JsonValue::_capnpPrivate::kind;
constexpr ::capnp::_::RawSchema const* JsonValue::_capnpPrivate::schema;
constexpr ::capnp::Kind Value::Field::_capnpPrivate::kind;
constexpr ::capnp::_::RawSchema const* Value::Field::_capnpPrivate::schema;
#endif // !CAPNP_LITE
// JsonValue::Field
constexpr uint16_t JsonValue::Field::_capnpPrivate::dataWordSize;
constexpr uint16_t JsonValue::Field::_capnpPrivate::pointerCount;
// Value::Call
constexpr uint16_t Value::Call::_capnpPrivate::dataWordSize;
constexpr uint16_t Value::Call::_capnpPrivate::pointerCount;
#if !CAPNP_LITE
constexpr ::capnp::Kind JsonValue::Field::_capnpPrivate::kind;
constexpr ::capnp::_::RawSchema const* JsonValue::Field::_capnpPrivate::schema;
constexpr ::capnp::Kind Value::Call::_capnpPrivate::kind;
constexpr ::capnp::_::RawSchema const* Value::Call::_capnpPrivate::schema;
#endif // !CAPNP_LITE
// JsonValue::Call
constexpr uint16_t JsonValue::Call::_capnpPrivate::dataWordSize;
constexpr uint16_t JsonValue::Call::_capnpPrivate::pointerCount;
// FlattenOptions
constexpr uint16_t FlattenOptions::_capnpPrivate::dataWordSize;
constexpr uint16_t FlattenOptions::_capnpPrivate::pointerCount;
#if !CAPNP_LITE
constexpr ::capnp::Kind JsonValue::Call::_capnpPrivate::kind;
constexpr ::capnp::_::RawSchema const* JsonValue::Call::_capnpPrivate::schema;
constexpr ::capnp::Kind FlattenOptions::_capnpPrivate::kind;
constexpr ::capnp::_::RawSchema const* FlattenOptions::_capnpPrivate::schema;
#endif // !CAPNP_LITE
// DiscriminatorOptions
constexpr uint16_t DiscriminatorOptions::_capnpPrivate::dataWordSize;
constexpr uint16_t DiscriminatorOptions::_capnpPrivate::pointerCount;
#if !CAPNP_LITE
constexpr ::capnp::Kind DiscriminatorOptions::_capnpPrivate::kind;
constexpr ::capnp::_::RawSchema const* DiscriminatorOptions::_capnpPrivate::schema;
#endif // !CAPNP_LITE
} // namespace
} // namespace
c++/src/capnp/compat/json.capnp.h
View file @ d76ba885
......@@ -17,17 +17,25 @@
namespace capnp {
namespace schemas {
CAPNP_DECLARE_SCHEMA(8825ffaa852cda72);
CAPNP_DECLARE_SCHEMA(c27855d853a937cc);
CAPNP_DECLARE_SCHEMA(9bbf84153dd4bb60);
CAPNP_DECLARE_SCHEMA(a3fa7845f919dd83);
CAPNP_DECLARE_SCHEMA(e31026e735d69ddf);
CAPNP_DECLARE_SCHEMA(a0d9f6eca1c93d48);
CAPNP_DECLARE_SCHEMA(fa5b1fd61c2e7c3d);
CAPNP_DECLARE_SCHEMA(82d3e852af0336bf);
CAPNP_DECLARE_SCHEMA(c4df13257bc2ea61);
CAPNP_DECLARE_SCHEMA(cfa794e8d19a0162);
CAPNP_DECLARE_SCHEMA(c2f8c20c293e5319);
CAPNP_DECLARE_SCHEMA(d7d879450a253e4b);
CAPNP_DECLARE_SCHEMA(f061e22f0ae5c7b5);
} // namespace schemas
} // namespace capnp
namespace capnp {
namespace json {
struct JsonValue {
JsonValue() = delete;
struct Value {
Value() = delete;
class Reader;
class Builder;
......@@ -45,14 +53,14 @@ struct JsonValue {
struct Call;
struct _capnpPrivate {
CAPNP_DECLARE_STRUCT_HEADER(8825ffaa852cda72, 2, 1)
CAPNP_DECLARE_STRUCT_HEADER(a3fa7845f919dd83, 2, 1)
#if !CAPNP_LITE
static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
#endif // !CAPNP_LITE
};
};
struct JsonValue::Field {
struct Value::Field {
Field() = delete;
class Reader;
......@@ -60,14 +68,14 @@ struct JsonValue::Field {
class Pipeline;
struct _capnpPrivate {
CAPNP_DECLARE_STRUCT_HEADER(c27855d853a937cc, 0, 2)
CAPNP_DECLARE_STRUCT_HEADER(e31026e735d69ddf, 0, 2)
#if !CAPNP_LITE
static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
#endif // !CAPNP_LITE
};
};
struct JsonValue::Call {
struct Value::Call {
Call() = delete;
class Reader;
......@@ -75,7 +83,37 @@ struct JsonValue::Call {
class Pipeline;
struct _capnpPrivate {
CAPNP_DECLARE_STRUCT_HEADER(9bbf84153dd4bb60, 0, 2)
CAPNP_DECLARE_STRUCT_HEADER(a0d9f6eca1c93d48, 0, 2)
#if !CAPNP_LITE
static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
#endif // !CAPNP_LITE
};
};
struct FlattenOptions {
FlattenOptions() = delete;
class Reader;
class Builder;
class Pipeline;
struct _capnpPrivate {
CAPNP_DECLARE_STRUCT_HEADER(c4df13257bc2ea61, 0, 1)
#if !CAPNP_LITE
static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
#endif // !CAPNP_LITE
};
};
struct DiscriminatorOptions {
DiscriminatorOptions() = delete;
class Reader;
class Builder;
class Pipeline;
struct _capnpPrivate {
CAPNP_DECLARE_STRUCT_HEADER(c2f8c20c293e5319, 0, 2)
#if !CAPNP_LITE
static constexpr ::capnp::_::RawBrandedSchema const* brand() { return &schema->defaultBrand; }
#endif // !CAPNP_LITE
......@@ -84,9 +122,9 @@ struct JsonValue::Call {
// =======================================================================================
class JsonValue::Reader {
class Value::Reader {
public:
typedef JsonValue Reads;
typedef Value Reads;
Reader() = default;
inline explicit Reader(::capnp::_::StructReader base): _reader(base) {}
......@@ -117,15 +155,15 @@ public:
inline bool isArray() const;
inline bool hasArray() const;
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Reader getArray() const;
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Reader getArray() const;
inline bool isObject() const;
inline bool hasObject() const;
inline ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>::Reader getObject() const;
inline ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>::Reader getObject() const;
inline bool isCall() const;
inline bool hasCall() const;
inline ::capnp::JsonValue::Call::Reader getCall() const;
inline ::capnp::json::Value::Call::Reader getCall() const;
private:
::capnp::_::StructReader _reader;
......@@ -139,9 +177,9 @@ private:
friend class ::capnp::Orphanage;
};
class JsonValue::Builder {
class Value::Builder {
public:
typedef JsonValue Builds;
typedef Value Builds;
Builder() = delete; // Deleted to discourage incorrect usage.
// You can explicitly initialize to nullptr instead.
......@@ -178,27 +216,27 @@ public:
inline bool isArray();
inline bool hasArray();
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Builder getArray();
inline void setArray( ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Reader value);
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Builder initArray(unsigned int size);
inline void adoptArray(::capnp::Orphan< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>&& value);
inline ::capnp::Orphan< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>> disownArray();
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Builder getArray();
inline void setArray( ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Reader value);
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Builder initArray(unsigned int size);
inline void adoptArray(::capnp::Orphan< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>&& value);
inline ::capnp::Orphan< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>> disownArray();
inline bool isObject();
inline bool hasObject();
inline ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>::Builder getObject();
inline void setObject( ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>::Reader value);
inline ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>::Builder initObject(unsigned int size);
inline void adoptObject(::capnp::Orphan< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>>&& value);
inline ::capnp::Orphan< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>> disownObject();
inline ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>::Builder getObject();
inline void setObject( ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>::Reader value);
inline ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>::Builder initObject(unsigned int size);
inline void adoptObject(::capnp::Orphan< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>>&& value);
inline ::capnp::Orphan< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>> disownObject();
inline bool isCall();
inline bool hasCall();
inline ::capnp::JsonValue::Call::Builder getCall();
inline void setCall( ::capnp::JsonValue::Call::Reader value);
inline ::capnp::JsonValue::Call::Builder initCall();
inline void adoptCall(::capnp::Orphan< ::capnp::JsonValue::Call>&& value);
inline ::capnp::Orphan< ::capnp::JsonValue::Call> disownCall();
inline ::capnp::json::Value::Call::Builder getCall();
inline void setCall( ::capnp::json::Value::Call::Reader value);
inline ::capnp::json::Value::Call::Builder initCall();
inline void adoptCall(::capnp::Orphan< ::capnp::json::Value::Call>&& value);
inline ::capnp::Orphan< ::capnp::json::Value::Call> disownCall();
private:
::capnp::_::StructBuilder _builder;
......@@ -210,9 +248,9 @@ private:
};
#if !CAPNP_LITE
class JsonValue::Pipeline {
class Value::Pipeline {
public:
typedef JsonValue Pipelines;
typedef Value Pipelines;
inline Pipeline(decltype(nullptr)): _typeless(nullptr) {}
inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
......@@ -226,7 +264,7 @@ private:
};
#endif // !CAPNP_LITE
class JsonValue::Field::Reader {
class Value::Field::Reader {
public:
typedef Field Reads;
......@@ -247,7 +285,7 @@ public:
inline ::capnp::Text::Reader getName() const;
inline bool hasValue() const;
inline ::capnp::JsonValue::Reader getValue() const;
inline ::capnp::json::Value::Reader getValue() const;
private:
::capnp::_::StructReader _reader;
......@@ -261,7 +299,7 @@ private:
friend class ::capnp::Orphanage;
};
class JsonValue::Field::Builder {
class Value::Field::Builder {
public:
typedef Field Builds;
......@@ -285,11 +323,11 @@ public:
inline ::capnp::Orphan< ::capnp::Text> disownName();
inline bool hasValue();
inline ::capnp::JsonValue::Builder getValue();
inline void setValue( ::capnp::JsonValue::Reader value);
inline ::capnp::JsonValue::Builder initValue();
inline void adoptValue(::capnp::Orphan< ::capnp::JsonValue>&& value);
inline ::capnp::Orphan< ::capnp::JsonValue> disownValue();
inline ::capnp::json::Value::Builder getValue();
inline void setValue( ::capnp::json::Value::Reader value);
inline ::capnp::json::Value::Builder initValue();
inline void adoptValue(::capnp::Orphan< ::capnp::json::Value>&& value);
inline ::capnp::Orphan< ::capnp::json::Value> disownValue();
private:
::capnp::_::StructBuilder _builder;
......@@ -301,7 +339,7 @@ private:
};
#if !CAPNP_LITE
class JsonValue::Field::Pipeline {
class Value::Field::Pipeline {
public:
typedef Field Pipelines;
......@@ -309,7 +347,7 @@ public:
inline explicit Pipeline(::capnp::AnyPointer::Pipeline&& typeless)
: _typeless(kj::mv(typeless)) {}
inline ::capnp::JsonValue::Pipeline getValue();
inline ::capnp::json::Value::Pipeline getValue();
private:
::capnp::AnyPointer::Pipeline _typeless;
friend class ::capnp::PipelineHook;
......@@ -318,7 +356,7 @@ private:
};
#endif // !CAPNP_LITE
class JsonValue::Call::Reader {
class Value::Call::Reader {
public:
typedef Call Reads;
......@@ -339,7 +377,7 @@ public:
inline ::capnp::Text::Reader getFunction() const;
inline bool hasParams() const;
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Reader getParams() const;
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Reader getParams() const;
private:
::capnp::_::StructReader _reader;
......@@ -353,7 +391,7 @@ private:
friend class ::capnp::Orphanage;
};
class JsonValue::Call::Builder {
class Value::Call::Builder {
public:
typedef Call Builds;
......@@ -377,11 +415,11 @@ public:
inline ::capnp::Orphan< ::capnp::Text> disownFunction();
inline bool hasParams();
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Builder getParams();
inline void setParams( ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Reader value);
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Builder initParams(unsigned int size);
inline void adoptParams(::capnp::Orphan< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>&& value);
inline ::capnp::Orphan< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>> disownParams();
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Builder getParams();
inline void setParams( ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Reader value);
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Builder initParams(unsigned int size);
inline void adoptParams(::capnp::Orphan< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>&& value);
inline ::capnp::Orphan< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>> disownParams();
private:
::capnp::_::StructBuilder _builder;
......@@ -393,7 +431,7 @@ private:
};
#if !CAPNP_LITE
class JsonValue::Call::Pipeline {
class Value::Call::Pipeline {
public:
typedef Call Pipelines;
......@@ -409,451 +447,728 @@ private:
};
#endif // !CAPNP_LITE
class FlattenOptions::Reader {
public:
typedef FlattenOptions 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 hasPrefix() const;
inline ::capnp::Text::Reader getPrefix() 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 FlattenOptions::Builder {
public:
typedef FlattenOptions 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 hasPrefix();
inline ::capnp::Text::Builder getPrefix();
inline void setPrefix( ::capnp::Text::Reader value);
inline ::capnp::Text::Builder initPrefix(unsigned int size);
inline void adoptPrefix(::capnp::Orphan< ::capnp::Text>&& value);
inline ::capnp::Orphan< ::capnp::Text> disownPrefix();
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 FlattenOptions::Pipeline {
public:
typedef FlattenOptions 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 DiscriminatorOptions::Reader {
public:
typedef DiscriminatorOptions 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 bool hasValueName() const;
inline ::capnp::Text::Reader getValueName() 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 DiscriminatorOptions::Builder {
public:
typedef DiscriminatorOptions 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 bool hasValueName();
inline ::capnp::Text::Builder getValueName();
inline void setValueName( ::capnp::Text::Reader value);
inline ::capnp::Text::Builder initValueName(unsigned int size);
inline void adoptValueName(::capnp::Orphan< ::capnp::Text>&& value);
inline ::capnp::Orphan< ::capnp::Text> disownValueName();
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 DiscriminatorOptions::Pipeline {
public:
typedef DiscriminatorOptions 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::JsonValue::Which JsonValue::Reader::which() const {
inline ::capnp::json::Value::Which Value::Reader::which() const {
return _reader.getDataField<Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline ::capnp::JsonValue::Which JsonValue::Builder::which() {
inline ::capnp::json::Value::Which Value::Builder::which() {
return _builder.getDataField<Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline bool JsonValue::Reader::isNull() const {
return which() == JsonValue::NULL_;
inline bool Value::Reader::isNull() const {
return which() == Value::NULL_;
}
inline bool JsonValue::Builder::isNull() {
return which() == JsonValue::NULL_;
inline bool Value::Builder::isNull() {
return which() == Value::NULL_;
}
inline ::capnp::Void JsonValue::Reader::getNull() const {
KJ_IREQUIRE((which() == JsonValue::NULL_),
inline ::capnp::Void Value::Reader::getNull() const {
KJ_IREQUIRE((which() == Value::NULL_),
"Must check which() before get()ing a union member.");
return _reader.getDataField< ::capnp::Void>(
::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline ::capnp::Void JsonValue::Builder::getNull() {
KJ_IREQUIRE((which() == JsonValue::NULL_),
inline ::capnp::Void Value::Builder::getNull() {
KJ_IREQUIRE((which() == Value::NULL_),
"Must check which() before get()ing a union member.");
return _builder.getDataField< ::capnp::Void>(
::capnp::bounded<0>() * ::capnp::ELEMENTS);
}
inline void JsonValue::Builder::setNull( ::capnp::Void value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::NULL_);
inline void Value::Builder::setNull( ::capnp::Void value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::NULL_);
_builder.setDataField< ::capnp::Void>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, value);
}
inline bool JsonValue::Reader::isBoolean() const {
return which() == JsonValue::BOOLEAN;
inline bool Value::Reader::isBoolean() const {
return which() == Value::BOOLEAN;
}
inline bool JsonValue::Builder::isBoolean() {
return which() == JsonValue::BOOLEAN;
inline bool Value::Builder::isBoolean() {
return which() == Value::BOOLEAN;
}
inline bool JsonValue::Reader::getBoolean() const {
KJ_IREQUIRE((which() == JsonValue::BOOLEAN),
inline bool Value::Reader::getBoolean() const {
KJ_IREQUIRE((which() == Value::BOOLEAN),
"Must check which() before get()ing a union member.");
return _reader.getDataField<bool>(
::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline bool JsonValue::Builder::getBoolean() {
KJ_IREQUIRE((which() == JsonValue::BOOLEAN),
inline bool Value::Builder::getBoolean() {
KJ_IREQUIRE((which() == Value::BOOLEAN),
"Must check which() before get()ing a union member.");
return _builder.getDataField<bool>(
::capnp::bounded<16>() * ::capnp::ELEMENTS);
}
inline void JsonValue::Builder::setBoolean(bool value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::BOOLEAN);
inline void Value::Builder::setBoolean(bool value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::BOOLEAN);
_builder.setDataField<bool>(
::capnp::bounded<16>() * ::capnp::ELEMENTS, value);
}
inline bool JsonValue::Reader::isNumber() const {
return which() == JsonValue::NUMBER;
inline bool Value::Reader::isNumber() const {
return which() == Value::NUMBER;
}
inline bool JsonValue::Builder::isNumber() {
return which() == JsonValue::NUMBER;
inline bool Value::Builder::isNumber() {
return which() == Value::NUMBER;
}
inline double JsonValue::Reader::getNumber() const {
KJ_IREQUIRE((which() == JsonValue::NUMBER),
inline double Value::Reader::getNumber() const {
KJ_IREQUIRE((which() == Value::NUMBER),
"Must check which() before get()ing a union member.");
return _reader.getDataField<double>(
::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline double JsonValue::Builder::getNumber() {
KJ_IREQUIRE((which() == JsonValue::NUMBER),
inline double Value::Builder::getNumber() {
KJ_IREQUIRE((which() == Value::NUMBER),
"Must check which() before get()ing a union member.");
return _builder.getDataField<double>(
::capnp::bounded<1>() * ::capnp::ELEMENTS);
}
inline void JsonValue::Builder::setNumber(double value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::NUMBER);
inline void Value::Builder::setNumber(double value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::NUMBER);
_builder.setDataField<double>(
::capnp::bounded<1>() * ::capnp::ELEMENTS, value);
}
inline bool JsonValue::Reader::isString() const {
return which() == JsonValue::STRING;
inline bool Value::Reader::isString() const {
return which() == Value::STRING;
}
inline bool JsonValue::Builder::isString() {
return which() == JsonValue::STRING;
inline bool Value::Builder::isString() {
return which() == Value::STRING;
}
inline bool JsonValue::Reader::hasString() const {
if (which() != JsonValue::STRING) return false;
inline bool Value::Reader::hasString() const {
if (which() != Value::STRING) return false;
return !_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool JsonValue::Builder::hasString() {
if (which() != JsonValue::STRING) return false;
inline bool Value::Builder::hasString() {
if (which() != Value::STRING) return false;
return !_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader JsonValue::Reader::getString() const {
KJ_IREQUIRE((which() == JsonValue::STRING),
inline ::capnp::Text::Reader Value::Reader::getString() const {
KJ_IREQUIRE((which() == Value::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 JsonValue::Builder::getString() {
KJ_IREQUIRE((which() == JsonValue::STRING),
inline ::capnp::Text::Builder Value::Builder::getString() {
KJ_IREQUIRE((which() == Value::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 JsonValue::Builder::setString( ::capnp::Text::Reader value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::STRING);
inline void Value::Builder::setString( ::capnp::Text::Reader value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::STRING);
::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder JsonValue::Builder::initString(unsigned int size) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::STRING);
inline ::capnp::Text::Builder Value::Builder::initString(unsigned int size) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::STRING);
return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void JsonValue::Builder::adoptString(
inline void Value::Builder::adoptString(
::capnp::Orphan< ::capnp::Text>&& value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::STRING);
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::STRING);
::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::Text> JsonValue::Builder::disownString() {
KJ_IREQUIRE((which() == JsonValue::STRING),
inline ::capnp::Orphan< ::capnp::Text> Value::Builder::disownString() {
KJ_IREQUIRE((which() == Value::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 JsonValue::Reader::isArray() const {
return which() == JsonValue::ARRAY;
inline bool Value::Reader::isArray() const {
return which() == Value::ARRAY;
}
inline bool JsonValue::Builder::isArray() {
return which() == JsonValue::ARRAY;
inline bool Value::Builder::isArray() {
return which() == Value::ARRAY;
}
inline bool JsonValue::Reader::hasArray() const {
if (which() != JsonValue::ARRAY) return false;
inline bool Value::Reader::hasArray() const {
if (which() != Value::ARRAY) return false;
return !_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool JsonValue::Builder::hasArray() {
if (which() != JsonValue::ARRAY) return false;
inline bool Value::Builder::hasArray() {
if (which() != Value::ARRAY) return false;
return !_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Reader JsonValue::Reader::getArray() const {
KJ_IREQUIRE((which() == JsonValue::ARRAY),
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Reader Value::Reader::getArray() const {
KJ_IREQUIRE((which() == Value::ARRAY),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Builder JsonValue::Builder::getArray() {
KJ_IREQUIRE((which() == JsonValue::ARRAY),
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Builder Value::Builder::getArray() {
KJ_IREQUIRE((which() == Value::ARRAY),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void JsonValue::Builder::setArray( ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Reader value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::ARRAY);
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
inline void Value::Builder::setArray( ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Reader value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::ARRAY);
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Builder JsonValue::Builder::initArray(unsigned int size) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::ARRAY);
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Builder Value::Builder::initArray(unsigned int size) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::ARRAY);
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void JsonValue::Builder::adoptArray(
::capnp::Orphan< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>&& value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::ARRAY);
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
inline void Value::Builder::adoptArray(
::capnp::Orphan< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>&& value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::ARRAY);
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>> JsonValue::Builder::disownArray() {
KJ_IREQUIRE((which() == JsonValue::ARRAY),
inline ::capnp::Orphan< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>> Value::Builder::disownArray() {
KJ_IREQUIRE((which() == Value::ARRAY),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline bool JsonValue::Reader::isObject() const {
return which() == JsonValue::OBJECT;
inline bool Value::Reader::isObject() const {
return which() == Value::OBJECT;
}
inline bool JsonValue::Builder::isObject() {
return which() == JsonValue::OBJECT;
inline bool Value::Builder::isObject() {
return which() == Value::OBJECT;
}
inline bool JsonValue::Reader::hasObject() const {
if (which() != JsonValue::OBJECT) return false;
inline bool Value::Reader::hasObject() const {
if (which() != Value::OBJECT) return false;
return !_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool JsonValue::Builder::hasObject() {
if (which() != JsonValue::OBJECT) return false;
inline bool Value::Builder::hasObject() {
if (which() != Value::OBJECT) return false;
return !_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>::Reader JsonValue::Reader::getObject() const {
KJ_IREQUIRE((which() == JsonValue::OBJECT),
inline ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>::Reader Value::Reader::getObject() const {
KJ_IREQUIRE((which() == Value::OBJECT),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>::Builder JsonValue::Builder::getObject() {
KJ_IREQUIRE((which() == JsonValue::OBJECT),
inline ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>::Builder Value::Builder::getObject() {
KJ_IREQUIRE((which() == Value::OBJECT),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void JsonValue::Builder::setObject( ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>::Reader value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::OBJECT);
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
inline void Value::Builder::setObject( ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>::Reader value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::OBJECT);
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>::Builder JsonValue::Builder::initObject(unsigned int size) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::OBJECT);
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
inline ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>::Builder Value::Builder::initObject(unsigned int size) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::OBJECT);
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void JsonValue::Builder::adoptObject(
::capnp::Orphan< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>>&& value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::OBJECT);
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
inline void Value::Builder::adoptObject(
::capnp::Orphan< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>>&& value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::OBJECT);
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>> JsonValue::Builder::disownObject() {
KJ_IREQUIRE((which() == JsonValue::OBJECT),
inline ::capnp::Orphan< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>> Value::Builder::disownObject() {
KJ_IREQUIRE((which() == Value::OBJECT),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue::Field, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value::Field, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline bool JsonValue::Reader::isCall() const {
return which() == JsonValue::CALL;
inline bool Value::Reader::isCall() const {
return which() == Value::CALL;
}
inline bool JsonValue::Builder::isCall() {
return which() == JsonValue::CALL;
inline bool Value::Builder::isCall() {
return which() == Value::CALL;
}
inline bool JsonValue::Reader::hasCall() const {
if (which() != JsonValue::CALL) return false;
inline bool Value::Reader::hasCall() const {
if (which() != Value::CALL) return false;
return !_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool JsonValue::Builder::hasCall() {
if (which() != JsonValue::CALL) return false;
inline bool Value::Builder::hasCall() {
if (which() != Value::CALL) return false;
return !_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::JsonValue::Call::Reader JsonValue::Reader::getCall() const {
KJ_IREQUIRE((which() == JsonValue::CALL),
inline ::capnp::json::Value::Call::Reader Value::Reader::getCall() const {
KJ_IREQUIRE((which() == Value::CALL),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::JsonValue::Call>::get(_reader.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::json::Value::Call>::get(_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::JsonValue::Call::Builder JsonValue::Builder::getCall() {
KJ_IREQUIRE((which() == JsonValue::CALL),
inline ::capnp::json::Value::Call::Builder Value::Builder::getCall() {
KJ_IREQUIRE((which() == Value::CALL),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::JsonValue::Call>::get(_builder.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::json::Value::Call>::get(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void JsonValue::Builder::setCall( ::capnp::JsonValue::Call::Reader value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::CALL);
::capnp::_::PointerHelpers< ::capnp::JsonValue::Call>::set(_builder.getPointerField(
inline void Value::Builder::setCall( ::capnp::json::Value::Call::Reader value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::CALL);
::capnp::_::PointerHelpers< ::capnp::json::Value::Call>::set(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::JsonValue::Call::Builder JsonValue::Builder::initCall() {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::CALL);
return ::capnp::_::PointerHelpers< ::capnp::JsonValue::Call>::init(_builder.getPointerField(
inline ::capnp::json::Value::Call::Builder Value::Builder::initCall() {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::CALL);
return ::capnp::_::PointerHelpers< ::capnp::json::Value::Call>::init(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void JsonValue::Builder::adoptCall(
::capnp::Orphan< ::capnp::JsonValue::Call>&& value) {
_builder.setDataField<JsonValue::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, JsonValue::CALL);
::capnp::_::PointerHelpers< ::capnp::JsonValue::Call>::adopt(_builder.getPointerField(
inline void Value::Builder::adoptCall(
::capnp::Orphan< ::capnp::json::Value::Call>&& value) {
_builder.setDataField<Value::Which>(
::capnp::bounded<0>() * ::capnp::ELEMENTS, Value::CALL);
::capnp::_::PointerHelpers< ::capnp::json::Value::Call>::adopt(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::JsonValue::Call> JsonValue::Builder::disownCall() {
KJ_IREQUIRE((which() == JsonValue::CALL),
inline ::capnp::Orphan< ::capnp::json::Value::Call> Value::Builder::disownCall() {
KJ_IREQUIRE((which() == Value::CALL),
"Must check which() before get()ing a union member.");
return ::capnp::_::PointerHelpers< ::capnp::JsonValue::Call>::disown(_builder.getPointerField(
return ::capnp::_::PointerHelpers< ::capnp::json::Value::Call>::disown(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline bool JsonValue::Field::Reader::hasName() const {
inline bool Value::Field::Reader::hasName() const {
return !_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool JsonValue::Field::Builder::hasName() {
inline bool Value::Field::Builder::hasName() {
return !_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader JsonValue::Field::Reader::getName() const {
inline ::capnp::Text::Reader Value::Field::Reader::getName() const {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder JsonValue::Field::Builder::getName() {
inline ::capnp::Text::Builder Value::Field::Builder::getName() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void JsonValue::Field::Builder::setName( ::capnp::Text::Reader value) {
inline void Value::Field::Builder::setName( ::capnp::Text::Reader value) {
::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder JsonValue::Field::Builder::initName(unsigned int size) {
inline ::capnp::Text::Builder Value::Field::Builder::initName(unsigned int size) {
return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void JsonValue::Field::Builder::adoptName(
inline void Value::Field::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> JsonValue::Field::Builder::disownName() {
inline ::capnp::Orphan< ::capnp::Text> Value::Field::Builder::disownName() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline bool JsonValue::Field::Reader::hasValue() const {
inline bool Value::Field::Reader::hasValue() const {
return !_reader.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool JsonValue::Field::Builder::hasValue() {
inline bool Value::Field::Builder::hasValue() {
return !_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::JsonValue::Reader JsonValue::Field::Reader::getValue() const {
return ::capnp::_::PointerHelpers< ::capnp::JsonValue>::get(_reader.getPointerField(
inline ::capnp::json::Value::Reader Value::Field::Reader::getValue() const {
return ::capnp::_::PointerHelpers< ::capnp::json::Value>::get(_reader.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::JsonValue::Builder JsonValue::Field::Builder::getValue() {
return ::capnp::_::PointerHelpers< ::capnp::JsonValue>::get(_builder.getPointerField(
inline ::capnp::json::Value::Builder Value::Field::Builder::getValue() {
return ::capnp::_::PointerHelpers< ::capnp::json::Value>::get(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
#if !CAPNP_LITE
inline ::capnp::JsonValue::Pipeline JsonValue::Field::Pipeline::getValue() {
return ::capnp::JsonValue::Pipeline(_typeless.getPointerField(1));
inline ::capnp::json::Value::Pipeline Value::Field::Pipeline::getValue() {
return ::capnp::json::Value::Pipeline(_typeless.getPointerField(1));
}
#endif // !CAPNP_LITE
inline void JsonValue::Field::Builder::setValue( ::capnp::JsonValue::Reader value) {
::capnp::_::PointerHelpers< ::capnp::JsonValue>::set(_builder.getPointerField(
inline void Value::Field::Builder::setValue( ::capnp::json::Value::Reader value) {
::capnp::_::PointerHelpers< ::capnp::json::Value>::set(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::JsonValue::Builder JsonValue::Field::Builder::initValue() {
return ::capnp::_::PointerHelpers< ::capnp::JsonValue>::init(_builder.getPointerField(
inline ::capnp::json::Value::Builder Value::Field::Builder::initValue() {
return ::capnp::_::PointerHelpers< ::capnp::json::Value>::init(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void Value::Field::Builder::adoptValue(
::capnp::Orphan< ::capnp::json::Value>&& value) {
::capnp::_::PointerHelpers< ::capnp::json::Value>::adopt(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::json::Value> Value::Field::Builder::disownValue() {
return ::capnp::_::PointerHelpers< ::capnp::json::Value>::disown(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline bool Value::Call::Reader::hasFunction() const {
return !_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool Value::Call::Builder::hasFunction() {
return !_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader Value::Call::Reader::getFunction() const {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder Value::Call::Builder::getFunction() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void Value::Call::Builder::setFunction( ::capnp::Text::Reader value) {
::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder Value::Call::Builder::initFunction(unsigned int size) {
return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void Value::Call::Builder::adoptFunction(
::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> Value::Call::Builder::disownFunction() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline bool Value::Call::Reader::hasParams() const {
return !_reader.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool Value::Call::Builder::hasParams() {
return !_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Reader Value::Call::Reader::getParams() const {
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void JsonValue::Field::Builder::adoptValue(
::capnp::Orphan< ::capnp::JsonValue>&& value) {
::capnp::_::PointerHelpers< ::capnp::JsonValue>::adopt(_builder.getPointerField(
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Builder Value::Call::Builder::getParams() {
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void Value::Call::Builder::setParams( ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Reader value) {
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>::Builder Value::Call::Builder::initParams(unsigned int size) {
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void Value::Call::Builder::adoptParams(
::capnp::Orphan< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>&& value) {
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::JsonValue> JsonValue::Field::Builder::disownValue() {
return ::capnp::_::PointerHelpers< ::capnp::JsonValue>::disown(_builder.getPointerField(
inline ::capnp::Orphan< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>> Value::Call::Builder::disownParams() {
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::json::Value, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline bool JsonValue::Call::Reader::hasFunction() const {
inline bool FlattenOptions::Reader::hasPrefix() const {
return !_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool JsonValue::Call::Builder::hasFunction() {
inline bool FlattenOptions::Builder::hasPrefix() {
return !_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader JsonValue::Call::Reader::getFunction() const {
inline ::capnp::Text::Reader FlattenOptions::Reader::getPrefix() const {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS),
::capnp::schemas::bp_c4df13257bc2ea61 + 34);
}
inline ::capnp::Text::Builder FlattenOptions::Builder::getPrefix() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS),
::capnp::schemas::bp_c4df13257bc2ea61 + 34);
}
inline void FlattenOptions::Builder::setPrefix( ::capnp::Text::Reader value) {
::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder FlattenOptions::Builder::initPrefix(unsigned int size) {
return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void FlattenOptions::Builder::adoptPrefix(
::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> FlattenOptions::Builder::disownPrefix() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline bool DiscriminatorOptions::Reader::hasName() const {
return !_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline bool DiscriminatorOptions::Builder::hasName() {
return !_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::Text::Reader DiscriminatorOptions::Reader::getName() const {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline ::capnp::Text::Builder JsonValue::Call::Builder::getFunction() {
inline ::capnp::Text::Builder DiscriminatorOptions::Builder::getName() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline void JsonValue::Call::Builder::setFunction( ::capnp::Text::Reader value) {
inline void DiscriminatorOptions::Builder::setName( ::capnp::Text::Reader value) {
::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), value);
}
inline ::capnp::Text::Builder JsonValue::Call::Builder::initFunction(unsigned int size) {
inline ::capnp::Text::Builder DiscriminatorOptions::Builder::initName(unsigned int size) {
return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS), size);
}
inline void JsonValue::Call::Builder::adoptFunction(
inline void DiscriminatorOptions::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> JsonValue::Call::Builder::disownFunction() {
inline ::capnp::Orphan< ::capnp::Text> DiscriminatorOptions::Builder::disownName() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
::capnp::bounded<0>() * ::capnp::POINTERS));
}
inline bool JsonValue::Call::Reader::hasParams() const {
inline bool DiscriminatorOptions::Reader::hasValueName() const {
return !_reader.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline bool JsonValue::Call::Builder::hasParams() {
inline bool DiscriminatorOptions::Builder::hasValueName() {
return !_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS).isNull();
}
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Reader JsonValue::Call::Reader::getParams() const {
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::get(_reader.getPointerField(
inline ::capnp::Text::Reader DiscriminatorOptions::Reader::getValueName() const {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_reader.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Builder JsonValue::Call::Builder::getParams() {
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::get(_builder.getPointerField(
inline ::capnp::Text::Builder DiscriminatorOptions::Builder::getValueName() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::get(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
inline void JsonValue::Call::Builder::setParams( ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Reader value) {
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::set(_builder.getPointerField(
inline void DiscriminatorOptions::Builder::setValueName( ::capnp::Text::Reader value) {
::capnp::_::PointerHelpers< ::capnp::Text>::set(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS), value);
}
inline ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>::Builder JsonValue::Call::Builder::initParams(unsigned int size) {
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::init(_builder.getPointerField(
inline ::capnp::Text::Builder DiscriminatorOptions::Builder::initValueName(unsigned int size) {
return ::capnp::_::PointerHelpers< ::capnp::Text>::init(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS), size);
}
inline void JsonValue::Call::Builder::adoptParams(
::capnp::Orphan< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>&& value) {
::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::adopt(_builder.getPointerField(
inline void DiscriminatorOptions::Builder::adoptValueName(
::capnp::Orphan< ::capnp::Text>&& value) {
::capnp::_::PointerHelpers< ::capnp::Text>::adopt(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS), kj::mv(value));
}
inline ::capnp::Orphan< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>> JsonValue::Call::Builder::disownParams() {
return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::JsonValue, ::capnp::Kind::STRUCT>>::disown(_builder.getPointerField(
inline ::capnp::Orphan< ::capnp::Text> DiscriminatorOptions::Builder::disownValueName() {
return ::capnp::_::PointerHelpers< ::capnp::Text>::disown(_builder.getPointerField(
::capnp::bounded<1>() * ::capnp::POINTERS));
}
} // namespace
} // namespace
c++/src/capnp/compat/json.h
View file @ d76ba885
......@@ -27,6 +27,11 @@
namespace capnp {
typedef json::Value JsonValue;
// For backwards-compatibility.
//
// TODO(cleanup): Consider replacing all uses of JsonValue with json::Value?
class JsonCodec {
// Flexible class for encoding Cap'n Proto types as JSON, and decoding JSON back to Cap'n Proto.
//
......@@ -198,6 +203,16 @@ public:
void addFieldHandler(StructSchema::Field field, Handler<T>& handler);
// Matches only the specific field. T can be a dynamic type. T must match the field's type.
void handleByAnnotation(Schema schema);
template <typename T> void handleByAnnotation();
// Inspects the given type (as specified by type parameter or dynamic schema) and all its
// dependencies looking for JSON annotations (see json.capnp), building and registering Handlers
// based on these annotations.
//
// If you'd like to use annotations to control JSON, you must call these functions before you
// start using the codec. They are not loaded "on demand" because that would require mutex
// locking.
// ---------------------------------------------------------------------------
// Hack to support string literal parameters
......@@ -214,6 +229,11 @@ public:
private:
class HandlerBase;
class AnnotatedHandler;
class AnnotatedEnumHandler;
class Base64Handler;
class HexHandler;
class JsonValueHandler;
struct Impl;
kj::Own<Impl> impl;
......@@ -222,8 +242,16 @@ private:
JsonValue::Builder output) const;
Orphan<DynamicList> decodeArray(List<JsonValue>::Reader input, ListSchema type, Orphanage orphanage) const;
void decodeObject(JsonValue::Reader input, StructSchema type, Orphanage orphanage, DynamicStruct::Builder output) const;
void decodeField(StructSchema::Field fieldSchema, JsonValue::Reader fieldValue,
Orphanage orphanage, DynamicStruct::Builder output) const;
void addTypeHandlerImpl(Type type, HandlerBase& handler);
void addFieldHandlerImpl(StructSchema::Field field, Type type, HandlerBase& handler);
AnnotatedHandler& loadAnnotatedHandler(
StructSchema schema,
kj::Maybe<json::DiscriminatorOptions::Reader> discriminator,
kj::Maybe<kj::StringPtr> unionDeclName,
kj::Vector<Schema>& dependencies);
};
// =======================================================================================
......@@ -480,4 +508,9 @@ template <> void JsonCodec::addTypeHandler(Handler<DynamicCapability>& handler)
// TODO(someday): Implement support for registering handlers that cover thinsg like "all structs"
// or "all lists". Currently you can only target a specific struct or list type.
template <typename T>
void JsonCodec::handleByAnnotation() {
return handleByAnnotation(Schema::from<T>());
}
} // namespace capnp
c++/src/capnp/compiler/capnp-test.sh
View file @ d76ba885
......@@ -38,7 +38,9 @@ else
fi
SCHEMA=`dirname "$0"`/../test.capnp
JSON_SCHEMA=`dirname "$0"`/../compat/json-test.capnp
TESTDATA=`dirname "$0"`/../testdata
SRCDIR=`dirname "$0"`/../..
SUFFIX=${TESTDATA#*/src/}
PREFIX=${TESTDATA%${SUFFIX}}
......@@ -74,6 +76,9 @@ $CAPNP convert binary:json --short $SCHEMA TestAllTypes < $TESTDATA/binary | cmp
$CAPNP convert json:binary $SCHEMA TestAllTypes < $TESTDATA/pretty.json | cmp $TESTDATA/binary - || fail json to binary
$CAPNP convert json:binary $SCHEMA TestAllTypes < $TESTDATA/short.json | cmp $TESTDATA/binary - || fail short json to binary
$CAPNP convert json:binary $JSON_SCHEMA TestJsonAnnotations -I"$SRCDIR" < $TESTDATA/annotated.json | cmp $TESTDATA/annotated-json.binary || fail annotated json to binary
$CAPNP convert binary:json $JSON_SCHEMA TestJsonAnnotations -I"$SRCDIR" < $TESTDATA/annotated-json.binary | cmp $TESTDATA/annotated.json || fail annotated json to binary
# ========================================================================================
# DEPRECATED encode/decode
......
c++/src/capnp/compiler/capnp.c++
View file @ d76ba885
......@@ -714,6 +714,13 @@ public:
return kj::str("unknown format: ", to);
}
if (convertFrom == Format::JSON || convertTo == Format::JSON) {
// We need annotations to process JSON.
// TODO(someday): Find a way that we can process annotations from json.capnp without
// requiring other annotation-only imports like c++.capnp
annotationFlag = Compiler::COMPILE_ANNOTATIONS;
}
return true;
} else {
return "invalid conversion, format is: <from>:<to>";
......@@ -1038,6 +1045,7 @@ private:
MallocMessageBuilder message;
JsonCodec codec;
codec.setPrettyPrint(pretty);
codec.handleByAnnotation(rootType);
auto root = message.initRoot<DynamicStruct>(rootType);
codec.decode(text, root);
return writeConversion(root.asReader(), output);
......@@ -1096,6 +1104,7 @@ private:
case Format::JSON: {
JsonCodec codec;
codec.setPrettyPrint(pretty);
codec.handleByAnnotation(rootType);
auto text = codec.encode(reader.as<DynamicStruct>(rootType));
output.write({text.asBytes(), kj::StringPtr("\n").asBytes()});
return;
......
c++/src/capnp/dynamic.h
View file @ d76ba885
......@@ -262,7 +262,7 @@ public:
template <typename T, typename = kj::EnableIf<kind<FromBuilder<T>>() == Kind::STRUCT>>
inline Builder(T&& value): Builder(toDynamic(value)) {}
inline operator AnyStruct::Reader() { return AnyStruct::Builder(builder); }
inline operator AnyStruct::Builder() { return AnyStruct::Builder(builder); }
inline MessageSize totalSize() const { return asReader().totalSize(); }
......
c++/src/capnp/generated-header-support.h
View file @ d76ba885
......@@ -35,6 +35,7 @@
#include "any.h"
#include <kj/string.h>
#include <kj/string-tree.h>
#include <kj/hash.h>
namespace capnp {
......
c++/src/capnp/schema.c++
View file @ d76ba885
......@@ -25,6 +25,12 @@
namespace capnp {
namespace schema {
uint KJ_HASHCODE(Type::Which w) { return kj::hashCode(static_cast<uint16_t>(w)); }
// TODO(cleanup): Cap'n Proto does not declare stringifiers nor hashers for `Which` enums, unlike
// all other enums. Fix that and remove this.
}
namespace _ { // private
// Null schemas generated using the below schema file with:
......@@ -868,7 +874,7 @@ bool Type::operator==(const Type& other) const {
KJ_UNREACHABLE;
}
size_t Type::hashCode() const {
uint Type::hashCode() const {
switch (baseType) {
case schema::Type::VOID:
case schema::Type::BOOL:
......@@ -884,12 +890,12 @@ size_t Type::hashCode() const {
case schema::Type::FLOAT64:
case schema::Type::TEXT:
case schema::Type::DATA:
return (static_cast<size_t>(baseType) << 3) + listDepth;
return kj::hashCode(baseType, listDepth);
case schema::Type::STRUCT:
case schema::Type::ENUM:
case schema::Type::INTERFACE:
return reinterpret_cast<size_t>(schema) + listDepth;
return kj::hashCode(schema, listDepth);
case schema::Type::LIST:
KJ_UNREACHABLE;
......@@ -897,9 +903,9 @@ size_t Type::hashCode() const {
case schema::Type::ANY_POINTER: {
// Trying to comply with strict aliasing rules. Hopefully the compiler realizes that
// both branches compile to the same instructions and can optimize it away.
size_t val = scopeId != 0 || isImplicitParam ?
uint16_t val = scopeId != 0 || isImplicitParam ?
paramIndex : static_cast<uint16_t>(anyPointerKind);
return (val << 1 | isImplicitParam) ^ scopeId;
return kj::hashCode(val, isImplicitParam, scopeId);
}
}
......
c++/src/capnp/schema.h
View file @ d76ba885
......@@ -30,6 +30,7 @@
#endif
#include <capnp/schema.capnp.h>
#include <kj/hash.h>
#include <kj/windows-sanity.h> // work-around macro conflict with `VOID`
namespace capnp {
......@@ -129,6 +130,8 @@ public:
// you want to check if two Schemas represent the same type (but possibly different versions of
// it), compare their IDs instead.
inline uint hashCode() const { return kj::hashCode(raw); }
template <typename T>
void requireUsableAs() const;
// Throws an exception if a value with this Schema cannot safely be cast to a native value of
......@@ -302,6 +305,7 @@ public:
inline bool operator==(const Field& other) const;
inline bool operator!=(const Field& other) const { return !(*this == other); }
inline uint hashCode() const;
private:
StructSchema parent;
......@@ -400,6 +404,7 @@ public:
inline bool operator==(const Enumerant& other) const;
inline bool operator!=(const Enumerant& other) const { return !(*this == other); }
inline uint hashCode() const;
private:
EnumSchema parent;
......@@ -492,6 +497,7 @@ public:
inline bool operator==(const Method& other) const;
inline bool operator!=(const Method& other) const { return !(*this == other); }
inline uint hashCode() const;
private:
InterfaceSchema parent;
......@@ -644,7 +650,7 @@ public:
bool operator==(const Type& other) const;
inline bool operator!=(const Type& other) const { return !(*this == other); }
size_t hashCode() const;
uint hashCode() const;
inline Type wrapInList(uint depth = 1) const;
// Return the Type formed by wrapping this type in List() `depth` times.
......@@ -796,6 +802,16 @@ inline bool InterfaceSchema::Method::operator==(const Method& other) const {
return parent == other.parent && ordinal == other.ordinal;
}
inline uint StructSchema::Field::hashCode() const {
return kj::hashCode(parent, index);
}
inline uint EnumSchema::Enumerant::hashCode() const {
return kj::hashCode(parent, ordinal);
}
inline uint InterfaceSchema::Method::hashCode() const {
return kj::hashCode(parent, ordinal);
}
inline ListSchema ListSchema::of(StructSchema elementType) {
return ListSchema(Type(elementType));
}
......
c++/src/capnp/testdata/annotated.json 0 → 100644
View file @ d76ba885
{ "names-can_contain!anything Really": "foo",
"flatFoo": 123,
"flatBar": "abc",
"renamed-flatBaz": {"hello": true},
"flatQux": "cba",
"pfx.foo": "this is a long string in order to force multi-line pretty printing",
"pfx.renamed-bar": 321,
"pfx.baz": {"hello": true},
"pfx.xfp.qux": "fed",
"union-type": "renamed-bar",
"barMember": 789,
"multiMember": "ghi",
"dependency": {"renamed-foo": "corge"},
"simpleGroup": {"renamed-grault": "garply"},
"enums": ["qux", "renamed-bar", "foo", "renamed-baz"],
"innerJson": [123, "hello", {"object": true}],
"testBase64": "ZnJlZA==",
"testHex": "706c756768",
"bUnion": "renamed-bar",
"bValue": 678 }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment