cannam@62: // Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
cannam@62: // Licensed under the MIT License:
cannam@62: //
cannam@62: // Permission is hereby granted, free of charge, to any person obtaining a copy
cannam@62: // of this software and associated documentation files (the "Software"), to deal
cannam@62: // in the Software without restriction, including without limitation the rights
cannam@62: // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
cannam@62: // copies of the Software, and to permit persons to whom the Software is
cannam@62: // furnished to do so, subject to the following conditions:
cannam@62: //
cannam@62: // The above copyright notice and this permission notice shall be included in
cannam@62: // all copies or substantial portions of the Software.
cannam@62: //
cannam@62: // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
cannam@62: // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
cannam@62: // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
cannam@62: // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
cannam@62: // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
cannam@62: // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
cannam@62: // THE SOFTWARE.
cannam@62:
cannam@62: // This file defines classes that can be used to manipulate messages based on schemas that are not
cannam@62: // known until runtime. This is also useful for writing generic code that uses schemas to handle
cannam@62: // arbitrary types in a generic way.
cannam@62: //
cannam@62: // Each of the classes defined here has a to() template method which converts an instance back to a
cannam@62: // native type. This method will throw an exception if the requested type does not match the
cannam@62: // schema. To convert native types to dynamic, use DynamicFactory.
cannam@62: //
cannam@62: // As always, underlying data is validated lazily, so you have to actually traverse the whole
cannam@62: // message if you want to validate all content.
cannam@62:
cannam@62: #ifndef CAPNP_DYNAMIC_H_
cannam@62: #define CAPNP_DYNAMIC_H_
cannam@62:
cannam@62: #if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
cannam@62: #pragma GCC system_header
cannam@62: #endif
cannam@62:
cannam@62: #include "schema.h"
cannam@62: #include "layout.h"
cannam@62: #include "message.h"
cannam@62: #include "any.h"
cannam@62: #include "capability.h"
cannam@62:
cannam@62: namespace capnp {
cannam@62:
cannam@62: class MessageReader;
cannam@62: class MessageBuilder;
cannam@62:
cannam@62: struct DynamicValue {
cannam@62: DynamicValue() = delete;
cannam@62:
cannam@62: enum Type {
cannam@62: UNKNOWN,
cannam@62: // Means that the value has unknown type and content because it comes from a newer version of
cannam@62: // the schema, or from a newer version of Cap'n Proto that has new features that this version
cannam@62: // doesn't understand.
cannam@62:
cannam@62: VOID,
cannam@62: BOOL,
cannam@62: INT,
cannam@62: UINT,
cannam@62: FLOAT,
cannam@62: TEXT,
cannam@62: DATA,
cannam@62: LIST,
cannam@62: ENUM,
cannam@62: STRUCT,
cannam@62: CAPABILITY,
cannam@62: ANY_POINTER
cannam@62: };
cannam@62:
cannam@62: class Reader;
cannam@62: class Builder;
cannam@62: class Pipeline;
cannam@62: };
cannam@62: class DynamicEnum;
cannam@62: struct DynamicStruct {
cannam@62: DynamicStruct() = delete;
cannam@62: class Reader;
cannam@62: class Builder;
cannam@62: class Pipeline;
cannam@62: };
cannam@62: struct DynamicList {
cannam@62: DynamicList() = delete;
cannam@62: class Reader;
cannam@62: class Builder;
cannam@62: };
cannam@62: struct DynamicCapability {
cannam@62: DynamicCapability() = delete;
cannam@62: class Client;
cannam@62: class Server;
cannam@62: };
cannam@62: template <> class Orphan<DynamicValue>;
cannam@62:
cannam@62: template <Kind k> struct DynamicTypeFor_;
cannam@62: template <> struct DynamicTypeFor_<Kind::ENUM> { typedef DynamicEnum Type; };
cannam@62: template <> struct DynamicTypeFor_<Kind::STRUCT> { typedef DynamicStruct Type; };
cannam@62: template <> struct DynamicTypeFor_<Kind::LIST> { typedef DynamicList Type; };
cannam@62: template <> struct DynamicTypeFor_<Kind::INTERFACE> { typedef DynamicCapability Type; };
cannam@62:
cannam@62: template <typename T>
cannam@62: using DynamicTypeFor = typename DynamicTypeFor_<kind<T>()>::Type;
cannam@62:
cannam@62: template <typename T>
cannam@62: ReaderFor<DynamicTypeFor<FromReader<T>>> toDynamic(T&& value);
cannam@62: template <typename T>
cannam@62: BuilderFor<DynamicTypeFor<FromBuilder<T>>> toDynamic(T&& value);
cannam@62: template <typename T>
cannam@62: DynamicTypeFor<TypeIfEnum<T>> toDynamic(T&& value);
cannam@62: template <typename T>
cannam@62: typename DynamicTypeFor<FromServer<T>>::Client toDynamic(kj::Own<T>&& value);
cannam@62:
cannam@62: namespace _ { // private
cannam@62:
cannam@62: template <> struct Kind_<DynamicValue > { static constexpr Kind kind = Kind::OTHER; };
cannam@62: template <> struct Kind_<DynamicEnum > { static constexpr Kind kind = Kind::OTHER; };
cannam@62: template <> struct Kind_<DynamicStruct > { static constexpr Kind kind = Kind::OTHER; };
cannam@62: template <> struct Kind_<DynamicList > { static constexpr Kind kind = Kind::OTHER; };
cannam@62: template <> struct Kind_<DynamicCapability> { static constexpr Kind kind = Kind::OTHER; };
cannam@62:
cannam@62: } // namespace _ (private)
cannam@62:
cannam@62: template <> inline constexpr Style style<DynamicValue >() { return Style::POINTER; }
cannam@62: template <> inline constexpr Style style<DynamicEnum >() { return Style::PRIMITIVE; }
cannam@62: template <> inline constexpr Style style<DynamicStruct >() { return Style::STRUCT; }
cannam@62: template <> inline constexpr Style style<DynamicList >() { return Style::POINTER; }
cannam@62: template <> inline constexpr Style style<DynamicCapability>() { return Style::CAPABILITY; }
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: class DynamicEnum {
cannam@62: public:
cannam@62: DynamicEnum() = default;
cannam@62: inline DynamicEnum(EnumSchema::Enumerant enumerant)
cannam@62: : schema(enumerant.getContainingEnum()), value(enumerant.getOrdinal()) {}
cannam@62: inline DynamicEnum(EnumSchema schema, uint16_t value)
cannam@62: : schema(schema), value(value) {}
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<T>() == Kind::ENUM>>
cannam@62: inline DynamicEnum(T&& value): DynamicEnum(toDynamic(value)) {}
cannam@62:
cannam@62: template <typename T>
cannam@62: inline T as() const { return static_cast<T>(asImpl(typeId<T>())); }
cannam@62: // Cast to a native enum type.
cannam@62:
cannam@62: inline EnumSchema getSchema() const { return schema; }
cannam@62:
cannam@62: kj::Maybe<EnumSchema::Enumerant> getEnumerant() const;
cannam@62: // Get which enumerant this enum value represents. Returns nullptr if the numeric value does not
cannam@62: // correspond to any enumerant in the schema -- this can happen if the data was built using a
cannam@62: // newer schema that has more values defined.
cannam@62:
cannam@62: inline uint16_t getRaw() const { return value; }
cannam@62: // Returns the raw underlying enum value.
cannam@62:
cannam@62: private:
cannam@62: EnumSchema schema;
cannam@62: uint16_t value;
cannam@62:
cannam@62: uint16_t asImpl(uint64_t requestedTypeId) const;
cannam@62:
cannam@62: friend struct DynamicStruct;
cannam@62: friend struct DynamicList;
cannam@62: friend struct DynamicValue;
cannam@62: template <typename T>
cannam@62: friend DynamicTypeFor<TypeIfEnum<T>> toDynamic(T&& value);
cannam@62: };
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: class DynamicStruct::Reader {
cannam@62: public:
cannam@62: typedef DynamicStruct Reads;
cannam@62:
cannam@62: Reader() = default;
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<FromReader<T>>() == Kind::STRUCT>>
cannam@62: inline Reader(T&& value): Reader(toDynamic(value)) {}
cannam@62:
cannam@62: inline MessageSize totalSize() const { return reader.totalSize().asPublic(); }
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Reader as() const;
cannam@62: // Convert the dynamic struct to its compiled-in type.
cannam@62:
cannam@62: inline StructSchema getSchema() const { return schema; }
cannam@62:
cannam@62: DynamicValue::Reader get(StructSchema::Field field) const;
cannam@62: // Read the given field value.
cannam@62:
cannam@62: bool has(StructSchema::Field field) const;
cannam@62: // Tests whether the given field is set to its default value. For pointer values, this does
cannam@62: // not actually traverse the value comparing it with the default, but simply returns true if the
cannam@62: // pointer is non-null. For members of unions, has() returns false if the union member is not
cannam@62: // active, but does not necessarily return true if the member is active (depends on the field's
cannam@62: // value).
cannam@62:
cannam@62: kj::Maybe<StructSchema::Field> which() const;
cannam@62: // If the struct contains an (unnamed) union, and the currently-active field within that union
cannam@62: // is known, this returns that field. Otherwise, it returns null. In other words, this returns
cannam@62: // null if there is no union present _or_ if the union's discriminant is set to an unrecognized
cannam@62: // value. This could happen in particular when receiving a message from a sender who has a
cannam@62: // newer version of the protocol and is using a field of the union that you don't know about yet.
cannam@62:
cannam@62: DynamicValue::Reader get(kj::StringPtr name) const;
cannam@62: bool has(kj::StringPtr name) const;
cannam@62: // Shortcuts to access fields by name. These throw exceptions if no such field exists.
cannam@62:
cannam@62: private:
cannam@62: StructSchema schema;
cannam@62: _::StructReader reader;
cannam@62:
cannam@62: inline Reader(StructSchema schema, _::StructReader reader)
cannam@62: : schema(schema), reader(reader) {}
cannam@62: Reader(StructSchema schema, const _::OrphanBuilder& orphan);
cannam@62:
cannam@62: bool isSetInUnion(StructSchema::Field field) const;
cannam@62: void verifySetInUnion(StructSchema::Field field) const;
cannam@62: static DynamicValue::Reader getImpl(_::StructReader reader, StructSchema::Field field);
cannam@62:
cannam@62: template <typename T, Kind K>
cannam@62: friend struct _::PointerHelpers;
cannam@62: friend class DynamicStruct::Builder;
cannam@62: friend struct DynamicList;
cannam@62: friend class MessageReader;
cannam@62: friend class MessageBuilder;
cannam@62: template <typename T, ::capnp::Kind k>
cannam@62: friend struct ::capnp::ToDynamic_;
cannam@62: friend kj::StringTree _::structString(
cannam@62: _::StructReader reader, const _::RawBrandedSchema& schema);
cannam@62: friend class Orphanage;
cannam@62: friend class Orphan<DynamicStruct>;
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: friend class Orphan<AnyPointer>;
cannam@62: };
cannam@62:
cannam@62: class DynamicStruct::Builder {
cannam@62: public:
cannam@62: typedef DynamicStruct Builds;
cannam@62:
cannam@62: Builder() = default;
cannam@62: inline Builder(decltype(nullptr)) {}
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<FromBuilder<T>>() == Kind::STRUCT>>
cannam@62: inline Builder(T&& value): Builder(toDynamic(value)) {}
cannam@62:
cannam@62: inline MessageSize totalSize() const { return asReader().totalSize(); }
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Builder as();
cannam@62: // Cast to a particular struct type.
cannam@62:
cannam@62: inline StructSchema getSchema() const { return schema; }
cannam@62:
cannam@62: DynamicValue::Builder get(StructSchema::Field field);
cannam@62: // Read the given field value.
cannam@62:
cannam@62: inline bool has(StructSchema::Field field) { return asReader().has(field); }
cannam@62: // Tests whether the given field is set to its default value. For pointer values, this does
cannam@62: // not actually traverse the value comparing it with the default, but simply returns true if the
cannam@62: // pointer is non-null. For members of unions, has() returns whether the field is currently
cannam@62: // active and the union as a whole is non-default -- so, the only time has() will return false
cannam@62: // for an active union field is if it is the default active field and it has its default value.
cannam@62:
cannam@62: kj::Maybe<StructSchema::Field> which();
cannam@62: // If the struct contains an (unnamed) union, and the currently-active field within that union
cannam@62: // is known, this returns that field. Otherwise, it returns null. In other words, this returns
cannam@62: // null if there is no union present _or_ if the union's discriminant is set to an unrecognized
cannam@62: // value. This could happen in particular when receiving a message from a sender who has a
cannam@62: // newer version of the protocol and is using a field of the union that you don't know about yet.
cannam@62:
cannam@62: void set(StructSchema::Field field, const DynamicValue::Reader& value);
cannam@62: // Set the given field value.
cannam@62:
cannam@62: DynamicValue::Builder init(StructSchema::Field field);
cannam@62: DynamicValue::Builder init(StructSchema::Field field, uint size);
cannam@62: // Init a struct, list, or blob field.
cannam@62:
cannam@62: void adopt(StructSchema::Field field, Orphan<DynamicValue>&& orphan);
cannam@62: Orphan<DynamicValue> disown(StructSchema::Field field);
cannam@62: // Adopt/disown. This works even for non-pointer fields: adopt() becomes equivalent to set()
cannam@62: // and disown() becomes like get() followed by clear().
cannam@62:
cannam@62: void clear(StructSchema::Field field);
cannam@62: // Clear a field, setting it to its default value. For pointer fields, this actually makes the
cannam@62: // field null.
cannam@62:
cannam@62: DynamicValue::Builder get(kj::StringPtr name);
cannam@62: bool has(kj::StringPtr name);
cannam@62: void set(kj::StringPtr name, const DynamicValue::Reader& value);
cannam@62: void set(kj::StringPtr name, std::initializer_list<DynamicValue::Reader> value);
cannam@62: DynamicValue::Builder init(kj::StringPtr name);
cannam@62: DynamicValue::Builder init(kj::StringPtr name, uint size);
cannam@62: void adopt(kj::StringPtr name, Orphan<DynamicValue>&& orphan);
cannam@62: Orphan<DynamicValue> disown(kj::StringPtr name);
cannam@62: void clear(kj::StringPtr name);
cannam@62: // Shortcuts to access fields by name. These throw exceptions if no such field exists.
cannam@62:
cannam@62: Reader asReader() const;
cannam@62:
cannam@62: private:
cannam@62: StructSchema schema;
cannam@62: _::StructBuilder builder;
cannam@62:
cannam@62: inline Builder(StructSchema schema, _::StructBuilder builder)
cannam@62: : schema(schema), builder(builder) {}
cannam@62: Builder(StructSchema schema, _::OrphanBuilder& orphan);
cannam@62:
cannam@62: bool isSetInUnion(StructSchema::Field field);
cannam@62: void verifySetInUnion(StructSchema::Field field);
cannam@62: void setInUnion(StructSchema::Field field);
cannam@62:
cannam@62: template <typename T, Kind k>
cannam@62: friend struct _::PointerHelpers;
cannam@62: friend struct DynamicList;
cannam@62: friend class MessageReader;
cannam@62: friend class MessageBuilder;
cannam@62: template <typename T, ::capnp::Kind k>
cannam@62: friend struct ::capnp::ToDynamic_;
cannam@62: friend class Orphanage;
cannam@62: friend class Orphan<DynamicStruct>;
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: friend class Orphan<AnyPointer>;
cannam@62: };
cannam@62:
cannam@62: class DynamicStruct::Pipeline {
cannam@62: public:
cannam@62: typedef DynamicStruct Pipelines;
cannam@62:
cannam@62: inline Pipeline(decltype(nullptr)): typeless(nullptr) {}
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Pipeline releaseAs();
cannam@62: // Convert the dynamic pipeline to its compiled-in type.
cannam@62:
cannam@62: inline StructSchema getSchema() { return schema; }
cannam@62:
cannam@62: DynamicValue::Pipeline get(StructSchema::Field field);
cannam@62: // Read the given field value.
cannam@62:
cannam@62: DynamicValue::Pipeline get(kj::StringPtr name);
cannam@62: // Get by string name.
cannam@62:
cannam@62: private:
cannam@62: StructSchema schema;
cannam@62: AnyPointer::Pipeline typeless;
cannam@62:
cannam@62: inline explicit Pipeline(StructSchema schema, AnyPointer::Pipeline&& typeless)
cannam@62: : schema(schema), typeless(kj::mv(typeless)) {}
cannam@62:
cannam@62: friend class Request<DynamicStruct, DynamicStruct>;
cannam@62: };
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: class DynamicList::Reader {
cannam@62: public:
cannam@62: typedef DynamicList Reads;
cannam@62:
cannam@62: inline Reader(): reader(ElementSize::VOID) {}
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<FromReader<T>>() == Kind::LIST>>
cannam@62: inline Reader(T&& value): Reader(toDynamic(value)) {}
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Reader as() const;
cannam@62: // Try to convert to any List<T>, Data, or Text. Throws an exception if the underlying data
cannam@62: // can't possibly represent the requested type.
cannam@62:
cannam@62: inline ListSchema getSchema() const { return schema; }
cannam@62:
cannam@62: inline uint size() const { return unbound(reader.size() / ELEMENTS); }
cannam@62: DynamicValue::Reader operator[](uint index) const;
cannam@62:
cannam@62: typedef _::IndexingIterator<const Reader, DynamicValue::Reader> Iterator;
cannam@62: inline Iterator begin() const { return Iterator(this, 0); }
cannam@62: inline Iterator end() const { return Iterator(this, size()); }
cannam@62:
cannam@62: private:
cannam@62: ListSchema schema;
cannam@62: _::ListReader reader;
cannam@62:
cannam@62: Reader(ListSchema schema, _::ListReader reader): schema(schema), reader(reader) {}
cannam@62: Reader(ListSchema schema, const _::OrphanBuilder& orphan);
cannam@62:
cannam@62: template <typename T, Kind k>
cannam@62: friend struct _::PointerHelpers;
cannam@62: friend struct DynamicStruct;
cannam@62: friend class DynamicList::Builder;
cannam@62: template <typename T, ::capnp::Kind k>
cannam@62: friend struct ::capnp::ToDynamic_;
cannam@62: friend class Orphanage;
cannam@62: friend class Orphan<DynamicList>;
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: friend class Orphan<AnyPointer>;
cannam@62: };
cannam@62:
cannam@62: class DynamicList::Builder {
cannam@62: public:
cannam@62: typedef DynamicList Builds;
cannam@62:
cannam@62: inline Builder(): builder(ElementSize::VOID) {}
cannam@62: inline Builder(decltype(nullptr)): builder(ElementSize::VOID) {}
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<FromBuilder<T>>() == Kind::LIST>>
cannam@62: inline Builder(T&& value): Builder(toDynamic(value)) {}
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Builder as();
cannam@62: // Try to convert to any List<T>, Data, or Text. Throws an exception if the underlying data
cannam@62: // can't possibly represent the requested type.
cannam@62:
cannam@62: inline ListSchema getSchema() const { return schema; }
cannam@62:
cannam@62: inline uint size() const { return unbound(builder.size() / ELEMENTS); }
cannam@62: DynamicValue::Builder operator[](uint index);
cannam@62: void set(uint index, const DynamicValue::Reader& value);
cannam@62: DynamicValue::Builder init(uint index, uint size);
cannam@62: void adopt(uint index, Orphan<DynamicValue>&& orphan);
cannam@62: Orphan<DynamicValue> disown(uint index);
cannam@62:
cannam@62: typedef _::IndexingIterator<Builder, DynamicStruct::Builder> Iterator;
cannam@62: inline Iterator begin() { return Iterator(this, 0); }
cannam@62: inline Iterator end() { return Iterator(this, size()); }
cannam@62:
cannam@62: void copyFrom(std::initializer_list<DynamicValue::Reader> value);
cannam@62:
cannam@62: Reader asReader() const;
cannam@62:
cannam@62: private:
cannam@62: ListSchema schema;
cannam@62: _::ListBuilder builder;
cannam@62:
cannam@62: Builder(ListSchema schema, _::ListBuilder builder): schema(schema), builder(builder) {}
cannam@62: Builder(ListSchema schema, _::OrphanBuilder& orphan);
cannam@62:
cannam@62: template <typename T, Kind k>
cannam@62: friend struct _::PointerHelpers;
cannam@62: friend struct DynamicStruct;
cannam@62: template <typename T, ::capnp::Kind k>
cannam@62: friend struct ::capnp::ToDynamic_;
cannam@62: friend class Orphanage;
cannam@62: template <typename T, Kind k>
cannam@62: friend struct _::OrphanGetImpl;
cannam@62: friend class Orphan<DynamicList>;
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: friend class Orphan<AnyPointer>;
cannam@62: };
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: class DynamicCapability::Client: public Capability::Client {
cannam@62: public:
cannam@62: typedef DynamicCapability Calls;
cannam@62: typedef DynamicCapability Reads;
cannam@62:
cannam@62: Client() = default;
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<FromClient<T>>() == Kind::INTERFACE>>
cannam@62: inline Client(T&& client);
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kj::canConvert<T*, DynamicCapability::Server*>()>>
cannam@62: inline Client(kj::Own<T>&& server);
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<T>() == Kind::INTERFACE>>
cannam@62: typename T::Client as();
cannam@62: template <typename T, typename = kj::EnableIf<kind<T>() == Kind::INTERFACE>>
cannam@62: typename T::Client releaseAs();
cannam@62: // Convert to any client type.
cannam@62:
cannam@62: Client upcast(InterfaceSchema requestedSchema);
cannam@62: // Upcast to a superclass. Throws an exception if `schema` is not a superclass.
cannam@62:
cannam@62: inline InterfaceSchema getSchema() { return schema; }
cannam@62:
cannam@62: Request<DynamicStruct, DynamicStruct> newRequest(
cannam@62: InterfaceSchema::Method method, kj::Maybe<MessageSize> sizeHint = nullptr);
cannam@62: Request<DynamicStruct, DynamicStruct> newRequest(
cannam@62: kj::StringPtr methodName, kj::Maybe<MessageSize> sizeHint = nullptr);
cannam@62:
cannam@62: private:
cannam@62: InterfaceSchema schema;
cannam@62:
cannam@62: Client(InterfaceSchema schema, kj::Own<ClientHook>&& hook)
cannam@62: : Capability::Client(kj::mv(hook)), schema(schema) {}
cannam@62:
cannam@62: template <typename T>
cannam@62: inline Client(InterfaceSchema schema, kj::Own<T>&& server);
cannam@62:
cannam@62: friend struct Capability;
cannam@62: friend struct DynamicStruct;
cannam@62: friend struct DynamicList;
cannam@62: friend struct DynamicValue;
cannam@62: friend class Orphan<DynamicCapability>;
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: friend class Orphan<AnyPointer>;
cannam@62: template <typename T, Kind k>
cannam@62: friend struct _::PointerHelpers;
cannam@62: };
cannam@62:
cannam@62: class DynamicCapability::Server: public Capability::Server {
cannam@62: public:
cannam@62: typedef DynamicCapability Serves;
cannam@62:
cannam@62: Server(InterfaceSchema schema): schema(schema) {}
cannam@62:
cannam@62: virtual kj::Promise<void> call(InterfaceSchema::Method method,
cannam@62: CallContext<DynamicStruct, DynamicStruct> context) = 0;
cannam@62:
cannam@62: kj::Promise<void> dispatchCall(uint64_t interfaceId, uint16_t methodId,
cannam@62: CallContext<AnyPointer, AnyPointer> context) override final;
cannam@62:
cannam@62: inline InterfaceSchema getSchema() const { return schema; }
cannam@62:
cannam@62: private:
cannam@62: InterfaceSchema schema;
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: class Request<DynamicStruct, DynamicStruct>: public DynamicStruct::Builder {
cannam@62: // Specialization of `Request<T, U>` for DynamicStruct.
cannam@62:
cannam@62: public:
cannam@62: inline Request(DynamicStruct::Builder builder, kj::Own<RequestHook>&& hook,
cannam@62: StructSchema resultSchema)
cannam@62: : DynamicStruct::Builder(builder), hook(kj::mv(hook)), resultSchema(resultSchema) {}
cannam@62:
cannam@62: RemotePromise<DynamicStruct> send();
cannam@62: // Send the call and return a promise for the results.
cannam@62:
cannam@62: private:
cannam@62: kj::Own<RequestHook> hook;
cannam@62: StructSchema resultSchema;
cannam@62:
cannam@62: friend class Capability::Client;
cannam@62: friend struct DynamicCapability;
cannam@62: template <typename, typename>
cannam@62: friend class CallContext;
cannam@62: friend class RequestHook;
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: class CallContext<DynamicStruct, DynamicStruct>: public kj::DisallowConstCopy {
cannam@62: // Wrapper around CallContextHook with a specific return type.
cannam@62: //
cannam@62: // Methods of this class may only be called from within the server's event loop, not from other
cannam@62: // threads.
cannam@62:
cannam@62: public:
cannam@62: explicit CallContext(CallContextHook& hook, StructSchema paramType, StructSchema resultType);
cannam@62:
cannam@62: DynamicStruct::Reader getParams();
cannam@62: void releaseParams();
cannam@62: DynamicStruct::Builder getResults(kj::Maybe<MessageSize> sizeHint = nullptr);
cannam@62: DynamicStruct::Builder initResults(kj::Maybe<MessageSize> sizeHint = nullptr);
cannam@62: void setResults(DynamicStruct::Reader value);
cannam@62: void adoptResults(Orphan<DynamicStruct>&& value);
cannam@62: Orphanage getResultsOrphanage(kj::Maybe<MessageSize> sizeHint = nullptr);
cannam@62: template <typename SubParams>
cannam@62: kj::Promise<void> tailCall(Request<SubParams, DynamicStruct>&& tailRequest);
cannam@62: void allowCancellation();
cannam@62:
cannam@62: private:
cannam@62: CallContextHook* hook;
cannam@62: StructSchema paramType;
cannam@62: StructSchema resultType;
cannam@62:
cannam@62: friend class DynamicCapability::Server;
cannam@62: };
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: // Make sure ReaderFor<T> and BuilderFor<T> work for DynamicEnum, DynamicStruct, and
cannam@62: // DynamicList, so that we can define DynamicValue::as().
cannam@62:
cannam@62: template <> struct ReaderFor_ <DynamicEnum, Kind::OTHER> { typedef DynamicEnum Type; };
cannam@62: template <> struct BuilderFor_<DynamicEnum, Kind::OTHER> { typedef DynamicEnum Type; };
cannam@62: template <> struct ReaderFor_ <DynamicStruct, Kind::OTHER> { typedef DynamicStruct::Reader Type; };
cannam@62: template <> struct BuilderFor_<DynamicStruct, Kind::OTHER> { typedef DynamicStruct::Builder Type; };
cannam@62: template <> struct ReaderFor_ <DynamicList, Kind::OTHER> { typedef DynamicList::Reader Type; };
cannam@62: template <> struct BuilderFor_<DynamicList, Kind::OTHER> { typedef DynamicList::Builder Type; };
cannam@62: template <> struct ReaderFor_ <DynamicCapability, Kind::OTHER> { typedef DynamicCapability::Client Type; };
cannam@62: template <> struct BuilderFor_<DynamicCapability, Kind::OTHER> { typedef DynamicCapability::Client Type; };
cannam@62: template <> struct PipelineFor_<DynamicCapability, Kind::OTHER> { typedef DynamicCapability::Client Type; };
cannam@62:
cannam@62: class DynamicValue::Reader {
cannam@62: public:
cannam@62: typedef DynamicValue Reads;
cannam@62:
cannam@62: inline Reader(decltype(nullptr) n = nullptr); // UNKNOWN
cannam@62: inline Reader(Void value);
cannam@62: inline Reader(bool value);
cannam@62: inline Reader(char value);
cannam@62: inline Reader(signed char value);
cannam@62: inline Reader(short value);
cannam@62: inline Reader(int value);
cannam@62: inline Reader(long value);
cannam@62: inline Reader(long long value);
cannam@62: inline Reader(unsigned char value);
cannam@62: inline Reader(unsigned short value);
cannam@62: inline Reader(unsigned int value);
cannam@62: inline Reader(unsigned long value);
cannam@62: inline Reader(unsigned long long value);
cannam@62: inline Reader(float value);
cannam@62: inline Reader(double value);
cannam@62: inline Reader(const char* value); // Text
cannam@62: inline Reader(const Text::Reader& value);
cannam@62: inline Reader(const Data::Reader& value);
cannam@62: inline Reader(const DynamicList::Reader& value);
cannam@62: inline Reader(DynamicEnum value);
cannam@62: inline Reader(const DynamicStruct::Reader& value);
cannam@62: inline Reader(const AnyPointer::Reader& value);
cannam@62: inline Reader(DynamicCapability::Client& value);
cannam@62: inline Reader(DynamicCapability::Client&& value);
cannam@62: template <typename T, typename = kj::EnableIf<kj::canConvert<T*, DynamicCapability::Server*>()>>
cannam@62: inline Reader(kj::Own<T>&& value);
cannam@62: Reader(ConstSchema constant);
cannam@62:
cannam@62: template <typename T, typename = decltype(toDynamic(kj::instance<T>()))>
cannam@62: inline Reader(T&& value): Reader(toDynamic(kj::mv(value))) {}
cannam@62:
cannam@62: Reader(const Reader& other);
cannam@62: Reader(Reader&& other) noexcept;
cannam@62: ~Reader() noexcept(false);
cannam@62: Reader& operator=(const Reader& other);
cannam@62: Reader& operator=(Reader&& other);
cannam@62: // Unfortunately, we cannot use the implicit definitions of these since DynamicCapability is not
cannam@62: // trivially copyable.
cannam@62:
cannam@62: template <typename T>
cannam@62: inline ReaderFor<T> as() const { return AsImpl<T>::apply(*this); }
cannam@62: // Use to interpret the value as some Cap'n Proto type. Allowed types are:
cannam@62: // - Void, bool, [u]int{8,16,32,64}_t, float, double, any enum: Returns the raw value.
cannam@62: // - Text, Data, AnyPointer, any struct type: Returns the corresponding Reader.
cannam@62: // - List<T> for any T listed above: Returns List<T>::Reader.
cannam@62: // - DynamicEnum: Returns the corresponding type.
cannam@62: // - DynamicStruct, DynamicList: Returns the corresponding Reader.
cannam@62: // - Any capability type, including DynamicCapability: Returns the corresponding Client.
cannam@62: // - DynamicValue: Returns an identical Reader. Useful to avoid special-casing in generic code.
cannam@62: // (TODO(perf): On GCC 4.8 / Clang 3.3, provide rvalue-qualified version that avoids
cannam@62: // refcounting.)
cannam@62: //
cannam@62: // DynamicValue allows various implicit conversions, mostly just to make the interface friendlier.
cannam@62: // - Any integer can be converted to any other integer type so long as the actual value is within
cannam@62: // the new type's range.
cannam@62: // - Floating-point types can be converted to integers as long as no information would be lost
cannam@62: // in the conversion.
cannam@62: // - Integers can be converted to floating points. This may lose information, but won't throw.
cannam@62: // - Float32/Float64 can be converted between each other. Converting Float64 -> Float32 may lose
cannam@62: // information, but won't throw.
cannam@62: // - Text can be converted to an enum, if the Text matches one of the enumerant names (but not
cannam@62: // vice-versa).
cannam@62: // - Capabilities can be upcast (cast to a supertype), but not downcast.
cannam@62: //
cannam@62: // Any other conversion attempt will throw an exception.
cannam@62:
cannam@62: inline Type getType() const { return type; }
cannam@62: // Get the type of this value.
cannam@62:
cannam@62: private:
cannam@62: Type type;
cannam@62:
cannam@62: union {
cannam@62: Void voidValue;
cannam@62: bool boolValue;
cannam@62: int64_t intValue;
cannam@62: uint64_t uintValue;
cannam@62: double floatValue;
cannam@62: Text::Reader textValue;
cannam@62: Data::Reader dataValue;
cannam@62: DynamicList::Reader listValue;
cannam@62: DynamicEnum enumValue;
cannam@62: DynamicStruct::Reader structValue;
cannam@62: AnyPointer::Reader anyPointerValue;
cannam@62:
cannam@62: mutable DynamicCapability::Client capabilityValue;
cannam@62: // Declared mutable because `Client`s normally cannot be const.
cannam@62:
cannam@62: // Warning: Copy/move constructors assume all these types are trivially copyable except
cannam@62: // Capability.
cannam@62: };
cannam@62:
cannam@62: template <typename T, Kind kind = kind<T>()> struct AsImpl;
cannam@62: // Implementation backing the as() method. Needs to be a struct to allow partial
cannam@62: // specialization. Has a method apply() which does the work.
cannam@62:
cannam@62: friend class Orphanage; // to speed up newOrphanCopy(DynamicValue::Reader)
cannam@62: };
cannam@62:
cannam@62: class DynamicValue::Builder {
cannam@62: public:
cannam@62: typedef DynamicValue Builds;
cannam@62:
cannam@62: inline Builder(decltype(nullptr) n = nullptr); // UNKNOWN
cannam@62: inline Builder(Void value);
cannam@62: inline Builder(bool value);
cannam@62: inline Builder(char value);
cannam@62: inline Builder(signed char value);
cannam@62: inline Builder(short value);
cannam@62: inline Builder(int value);
cannam@62: inline Builder(long value);
cannam@62: inline Builder(long long value);
cannam@62: inline Builder(unsigned char value);
cannam@62: inline Builder(unsigned short value);
cannam@62: inline Builder(unsigned int value);
cannam@62: inline Builder(unsigned long value);
cannam@62: inline Builder(unsigned long long value);
cannam@62: inline Builder(float value);
cannam@62: inline Builder(double value);
cannam@62: inline Builder(Text::Builder value);
cannam@62: inline Builder(Data::Builder value);
cannam@62: inline Builder(DynamicList::Builder value);
cannam@62: inline Builder(DynamicEnum value);
cannam@62: inline Builder(DynamicStruct::Builder value);
cannam@62: inline Builder(AnyPointer::Builder value);
cannam@62: inline Builder(DynamicCapability::Client& value);
cannam@62: inline Builder(DynamicCapability::Client&& value);
cannam@62:
cannam@62: template <typename T, typename = decltype(toDynamic(kj::instance<T>()))>
cannam@62: inline Builder(T value): Builder(toDynamic(value)) {}
cannam@62:
cannam@62: Builder(Builder& other);
cannam@62: Builder(Builder&& other) noexcept;
cannam@62: ~Builder() noexcept(false);
cannam@62: Builder& operator=(Builder& other);
cannam@62: Builder& operator=(Builder&& other);
cannam@62: // Unfortunately, we cannot use the implicit definitions of these since DynamicCapability is not
cannam@62: // trivially copyable.
cannam@62:
cannam@62: template <typename T>
cannam@62: inline BuilderFor<T> as() { return AsImpl<T>::apply(*this); }
cannam@62: // See DynamicValue::Reader::as().
cannam@62:
cannam@62: inline Type getType() { return type; }
cannam@62: // Get the type of this value.
cannam@62:
cannam@62: Reader asReader() const;
cannam@62:
cannam@62: private:
cannam@62: Type type;
cannam@62:
cannam@62: union {
cannam@62: Void voidValue;
cannam@62: bool boolValue;
cannam@62: int64_t intValue;
cannam@62: uint64_t uintValue;
cannam@62: double floatValue;
cannam@62: Text::Builder textValue;
cannam@62: Data::Builder dataValue;
cannam@62: DynamicList::Builder listValue;
cannam@62: DynamicEnum enumValue;
cannam@62: DynamicStruct::Builder structValue;
cannam@62: AnyPointer::Builder anyPointerValue;
cannam@62:
cannam@62: mutable DynamicCapability::Client capabilityValue;
cannam@62: // Declared mutable because `Client`s normally cannot be const.
cannam@62: };
cannam@62:
cannam@62: template <typename T, Kind kind = kind<T>()> struct AsImpl;
cannam@62: // Implementation backing the as() method. Needs to be a struct to allow partial
cannam@62: // specialization. Has a method apply() which does the work.
cannam@62:
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: };
cannam@62:
cannam@62: class DynamicValue::Pipeline {
cannam@62: public:
cannam@62: typedef DynamicValue Pipelines;
cannam@62:
cannam@62: inline Pipeline(decltype(nullptr) n = nullptr);
cannam@62: inline Pipeline(DynamicStruct::Pipeline&& value);
cannam@62: inline Pipeline(DynamicCapability::Client&& value);
cannam@62:
cannam@62: Pipeline(Pipeline&& other) noexcept;
cannam@62: Pipeline& operator=(Pipeline&& other);
cannam@62: ~Pipeline() noexcept(false);
cannam@62:
cannam@62: template <typename T>
cannam@62: inline PipelineFor<T> releaseAs() { return AsImpl<T>::apply(*this); }
cannam@62:
cannam@62: inline Type getType() { return type; }
cannam@62: // Get the type of this value.
cannam@62:
cannam@62: private:
cannam@62: Type type;
cannam@62: union {
cannam@62: DynamicStruct::Pipeline structValue;
cannam@62: DynamicCapability::Client capabilityValue;
cannam@62: };
cannam@62:
cannam@62: template <typename T, Kind kind = kind<T>()> struct AsImpl;
cannam@62: // Implementation backing the releaseAs() method. Needs to be a struct to allow partial
cannam@62: // specialization. Has a method apply() which does the work.
cannam@62: };
cannam@62:
cannam@62: kj::StringTree KJ_STRINGIFY(const DynamicValue::Reader& value);
cannam@62: kj::StringTree KJ_STRINGIFY(const DynamicValue::Builder& value);
cannam@62: kj::StringTree KJ_STRINGIFY(DynamicEnum value);
cannam@62: kj::StringTree KJ_STRINGIFY(const DynamicStruct::Reader& value);
cannam@62: kj::StringTree KJ_STRINGIFY(const DynamicStruct::Builder& value);
cannam@62: kj::StringTree KJ_STRINGIFY(const DynamicList::Reader& value);
cannam@62: kj::StringTree KJ_STRINGIFY(const DynamicList::Builder& value);
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62: // Orphan <-> Dynamic glue
cannam@62:
cannam@62: template <>
cannam@62: class Orphan<DynamicStruct> {
cannam@62: public:
cannam@62: Orphan() = default;
cannam@62: KJ_DISALLOW_COPY(Orphan);
cannam@62: Orphan(Orphan&&) = default;
cannam@62: Orphan& operator=(Orphan&&) = default;
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<T>() == Kind::STRUCT>>
cannam@62: inline Orphan(Orphan<T>&& other): schema(Schema::from<T>()), builder(kj::mv(other.builder)) {}
cannam@62:
cannam@62: DynamicStruct::Builder get();
cannam@62: DynamicStruct::Reader getReader() const;
cannam@62:
cannam@62: template <typename T>
cannam@62: Orphan<T> releaseAs();
cannam@62: // Like DynamicStruct::Builder::as(), but coerces the Orphan type. Since Orphans are move-only,
cannam@62: // the original Orphan<DynamicStruct> is no longer valid after this call; ownership is
cannam@62: // transferred to the returned Orphan<T>.
cannam@62:
cannam@62: inline bool operator==(decltype(nullptr)) const { return builder == nullptr; }
cannam@62: inline bool operator!=(decltype(nullptr)) const { return builder != nullptr; }
cannam@62:
cannam@62: private:
cannam@62: StructSchema schema;
cannam@62: _::OrphanBuilder builder;
cannam@62:
cannam@62: inline Orphan(StructSchema schema, _::OrphanBuilder&& builder)
cannam@62: : schema(schema), builder(kj::mv(builder)) {}
cannam@62:
cannam@62: template <typename, Kind>
cannam@62: friend struct _::PointerHelpers;
cannam@62: friend struct DynamicList;
cannam@62: friend class Orphanage;
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: friend class Orphan<AnyPointer>;
cannam@62: friend class MessageBuilder;
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: class Orphan<DynamicList> {
cannam@62: public:
cannam@62: Orphan() = default;
cannam@62: KJ_DISALLOW_COPY(Orphan);
cannam@62: Orphan(Orphan&&) = default;
cannam@62: Orphan& operator=(Orphan&&) = default;
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<T>() == Kind::LIST>>
cannam@62: inline Orphan(Orphan<T>&& other): schema(Schema::from<T>()), builder(kj::mv(other.builder)) {}
cannam@62:
cannam@62: DynamicList::Builder get();
cannam@62: DynamicList::Reader getReader() const;
cannam@62:
cannam@62: template <typename T>
cannam@62: Orphan<T> releaseAs();
cannam@62: // Like DynamicList::Builder::as(), but coerces the Orphan type. Since Orphans are move-only,
cannam@62: // the original Orphan<DynamicStruct> is no longer valid after this call; ownership is
cannam@62: // transferred to the returned Orphan<T>.
cannam@62:
cannam@62: // TODO(someday): Support truncate().
cannam@62:
cannam@62: inline bool operator==(decltype(nullptr)) const { return builder == nullptr; }
cannam@62: inline bool operator!=(decltype(nullptr)) const { return builder != nullptr; }
cannam@62:
cannam@62: private:
cannam@62: ListSchema schema;
cannam@62: _::OrphanBuilder builder;
cannam@62:
cannam@62: inline Orphan(ListSchema schema, _::OrphanBuilder&& builder)
cannam@62: : schema(schema), builder(kj::mv(builder)) {}
cannam@62:
cannam@62: template <typename, Kind>
cannam@62: friend struct _::PointerHelpers;
cannam@62: friend struct DynamicList;
cannam@62: friend class Orphanage;
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: friend class Orphan<AnyPointer>;
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: class Orphan<DynamicCapability> {
cannam@62: public:
cannam@62: Orphan() = default;
cannam@62: KJ_DISALLOW_COPY(Orphan);
cannam@62: Orphan(Orphan&&) = default;
cannam@62: Orphan& operator=(Orphan&&) = default;
cannam@62:
cannam@62: template <typename T, typename = kj::EnableIf<kind<T>() == Kind::INTERFACE>>
cannam@62: inline Orphan(Orphan<T>&& other): schema(Schema::from<T>()), builder(kj::mv(other.builder)) {}
cannam@62:
cannam@62: DynamicCapability::Client get();
cannam@62: DynamicCapability::Client getReader() const;
cannam@62:
cannam@62: template <typename T>
cannam@62: Orphan<T> releaseAs();
cannam@62: // Like DynamicCapability::Client::as(), but coerces the Orphan type. Since Orphans are move-only,
cannam@62: // the original Orphan<DynamicCapability> is no longer valid after this call; ownership is
cannam@62: // transferred to the returned Orphan<T>.
cannam@62:
cannam@62: inline bool operator==(decltype(nullptr)) const { return builder == nullptr; }
cannam@62: inline bool operator!=(decltype(nullptr)) const { return builder != nullptr; }
cannam@62:
cannam@62: private:
cannam@62: InterfaceSchema schema;
cannam@62: _::OrphanBuilder builder;
cannam@62:
cannam@62: inline Orphan(InterfaceSchema schema, _::OrphanBuilder&& builder)
cannam@62: : schema(schema), builder(kj::mv(builder)) {}
cannam@62:
cannam@62: template <typename, Kind>
cannam@62: friend struct _::PointerHelpers;
cannam@62: friend struct DynamicList;
cannam@62: friend class Orphanage;
cannam@62: friend class Orphan<DynamicValue>;
cannam@62: friend class Orphan<AnyPointer>;
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: class Orphan<DynamicValue> {
cannam@62: public:
cannam@62: inline Orphan(decltype(nullptr) n = nullptr): type(DynamicValue::UNKNOWN) {}
cannam@62: inline Orphan(Void value);
cannam@62: inline Orphan(bool value);
cannam@62: inline Orphan(char value);
cannam@62: inline Orphan(signed char value);
cannam@62: inline Orphan(short value);
cannam@62: inline Orphan(int value);
cannam@62: inline Orphan(long value);
cannam@62: inline Orphan(long long value);
cannam@62: inline Orphan(unsigned char value);
cannam@62: inline Orphan(unsigned short value);
cannam@62: inline Orphan(unsigned int value);
cannam@62: inline Orphan(unsigned long value);
cannam@62: inline Orphan(unsigned long long value);
cannam@62: inline Orphan(float value);
cannam@62: inline Orphan(double value);
cannam@62: inline Orphan(DynamicEnum value);
cannam@62: Orphan(Orphan&&) = default;
cannam@62: template <typename T>
cannam@62: Orphan(Orphan<T>&&);
cannam@62: Orphan(Orphan<AnyPointer>&&);
cannam@62: Orphan(void*) = delete; // So Orphan(bool) doesn't accept pointers.
cannam@62: KJ_DISALLOW_COPY(Orphan);
cannam@62:
cannam@62: Orphan& operator=(Orphan&&) = default;
cannam@62:
cannam@62: inline DynamicValue::Type getType() { return type; }
cannam@62:
cannam@62: DynamicValue::Builder get();
cannam@62: DynamicValue::Reader getReader() const;
cannam@62:
cannam@62: template <typename T>
cannam@62: Orphan<T> releaseAs();
cannam@62: // Like DynamicValue::Builder::as(), but coerces the Orphan type. Since Orphans are move-only,
cannam@62: // the original Orphan<DynamicStruct> is no longer valid after this call; ownership is
cannam@62: // transferred to the returned Orphan<T>.
cannam@62:
cannam@62: private:
cannam@62: DynamicValue::Type type;
cannam@62: union {
cannam@62: Void voidValue;
cannam@62: bool boolValue;
cannam@62: int64_t intValue;
cannam@62: uint64_t uintValue;
cannam@62: double floatValue;
cannam@62: DynamicEnum enumValue;
cannam@62: StructSchema structSchema;
cannam@62: ListSchema listSchema;
cannam@62: InterfaceSchema interfaceSchema;
cannam@62: };
cannam@62:
cannam@62: _::OrphanBuilder builder;
cannam@62: // Only used if `type` is a pointer type.
cannam@62:
cannam@62: Orphan(DynamicValue::Builder value, _::OrphanBuilder&& builder);
cannam@62: Orphan(DynamicValue::Type type, _::OrphanBuilder&& builder)
cannam@62: : type(type), builder(kj::mv(builder)) {}
cannam@62: Orphan(StructSchema structSchema, _::OrphanBuilder&& builder)
cannam@62: : type(DynamicValue::STRUCT), structSchema(structSchema), builder(kj::mv(builder)) {}
cannam@62: Orphan(ListSchema listSchema, _::OrphanBuilder&& builder)
cannam@62: : type(DynamicValue::LIST), listSchema(listSchema), builder(kj::mv(builder)) {}
cannam@62:
cannam@62: template <typename, Kind>
cannam@62: friend struct _::PointerHelpers;
cannam@62: friend struct DynamicStruct;
cannam@62: friend struct DynamicList;
cannam@62: friend struct AnyPointer;
cannam@62: friend class Orphanage;
cannam@62: };
cannam@62:
cannam@62: template <typename T>
cannam@62: inline Orphan<DynamicValue>::Orphan(Orphan<T>&& other)
cannam@62: : Orphan(other.get(), kj::mv(other.builder)) {}
cannam@62:
cannam@62: inline Orphan<DynamicValue>::Orphan(Orphan<AnyPointer>&& other)
cannam@62: : type(DynamicValue::ANY_POINTER), builder(kj::mv(other.builder)) {}
cannam@62:
cannam@62: template <typename T>
cannam@62: Orphan<T> Orphan<DynamicStruct>::releaseAs() {
cannam@62: get().as<T>(); // type check
cannam@62: return Orphan<T>(kj::mv(builder));
cannam@62: }
cannam@62:
cannam@62: template <typename T>
cannam@62: Orphan<T> Orphan<DynamicList>::releaseAs() {
cannam@62: get().as<T>(); // type check
cannam@62: return Orphan<T>(kj::mv(builder));
cannam@62: }
cannam@62:
cannam@62: template <typename T>
cannam@62: Orphan<T> Orphan<DynamicCapability>::releaseAs() {
cannam@62: get().as<T>(); // type check
cannam@62: return Orphan<T>(kj::mv(builder));
cannam@62: }
cannam@62:
cannam@62: template <typename T>
cannam@62: Orphan<T> Orphan<DynamicValue>::releaseAs() {
cannam@62: get().as<T>(); // type check
cannam@62: type = DynamicValue::UNKNOWN;
cannam@62: return Orphan<T>(kj::mv(builder));
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: Orphan<AnyPointer> Orphan<DynamicValue>::releaseAs<AnyPointer>();
cannam@62: template <>
cannam@62: Orphan<DynamicStruct> Orphan<DynamicValue>::releaseAs<DynamicStruct>();
cannam@62: template <>
cannam@62: Orphan<DynamicList> Orphan<DynamicValue>::releaseAs<DynamicList>();
cannam@62: template <>
cannam@62: Orphan<DynamicCapability> Orphan<DynamicValue>::releaseAs<DynamicCapability>();
cannam@62:
cannam@62: template <>
cannam@62: struct Orphanage::GetInnerBuilder<DynamicStruct, Kind::OTHER> {
cannam@62: static inline _::StructBuilder apply(DynamicStruct::Builder& t) {
cannam@62: return t.builder;
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: struct Orphanage::GetInnerBuilder<DynamicList, Kind::OTHER> {
cannam@62: static inline _::ListBuilder apply(DynamicList::Builder& t) {
cannam@62: return t.builder;
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: inline Orphan<DynamicStruct> Orphanage::newOrphanCopy<DynamicStruct::Reader>(
cannam@62: DynamicStruct::Reader copyFrom) const {
cannam@62: return Orphan<DynamicStruct>(
cannam@62: copyFrom.getSchema(), _::OrphanBuilder::copy(arena, capTable, copyFrom.reader));
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline Orphan<DynamicList> Orphanage::newOrphanCopy<DynamicList::Reader>(
cannam@62: DynamicList::Reader copyFrom) const {
cannam@62: return Orphan<DynamicList>(copyFrom.getSchema(),
cannam@62: _::OrphanBuilder::copy(arena, capTable, copyFrom.reader));
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline Orphan<DynamicCapability> Orphanage::newOrphanCopy<DynamicCapability::Client>(
cannam@62: DynamicCapability::Client copyFrom) const {
cannam@62: return Orphan<DynamicCapability>(
cannam@62: copyFrom.getSchema(), _::OrphanBuilder::copy(arena, capTable, copyFrom.hook->addRef()));
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: Orphan<DynamicValue> Orphanage::newOrphanCopy<DynamicValue::Reader>(
cannam@62: DynamicValue::Reader copyFrom) const;
cannam@62:
cannam@62: namespace _ { // private
cannam@62:
cannam@62: template <>
cannam@62: struct PointerHelpers<DynamicStruct, Kind::OTHER> {
cannam@62: // getDynamic() is used when an AnyPointer's get() accessor is passed arguments, because for
cannam@62: // non-dynamic types PointerHelpers::get() takes a default value as the third argument, and we
cannam@62: // don't want people to accidentally be able to provide their own default value.
cannam@62: static DynamicStruct::Reader getDynamic(PointerReader reader, StructSchema schema);
cannam@62: static DynamicStruct::Builder getDynamic(PointerBuilder builder, StructSchema schema);
cannam@62: static void set(PointerBuilder builder, const DynamicStruct::Reader& value);
cannam@62: static DynamicStruct::Builder init(PointerBuilder builder, StructSchema schema);
cannam@62: static inline void adopt(PointerBuilder builder, Orphan<DynamicStruct>&& value) {
cannam@62: builder.adopt(kj::mv(value.builder));
cannam@62: }
cannam@62: static inline Orphan<DynamicStruct> disown(PointerBuilder builder, StructSchema schema) {
cannam@62: return Orphan<DynamicStruct>(schema, builder.disown());
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: struct PointerHelpers<DynamicList, Kind::OTHER> {
cannam@62: // getDynamic() is used when an AnyPointer's get() accessor is passed arguments, because for
cannam@62: // non-dynamic types PointerHelpers::get() takes a default value as the third argument, and we
cannam@62: // don't want people to accidentally be able to provide their own default value.
cannam@62: static DynamicList::Reader getDynamic(PointerReader reader, ListSchema schema);
cannam@62: static DynamicList::Builder getDynamic(PointerBuilder builder, ListSchema schema);
cannam@62: static void set(PointerBuilder builder, const DynamicList::Reader& value);
cannam@62: static DynamicList::Builder init(PointerBuilder builder, ListSchema schema, uint size);
cannam@62: static inline void adopt(PointerBuilder builder, Orphan<DynamicList>&& value) {
cannam@62: builder.adopt(kj::mv(value.builder));
cannam@62: }
cannam@62: static inline Orphan<DynamicList> disown(PointerBuilder builder, ListSchema schema) {
cannam@62: return Orphan<DynamicList>(schema, builder.disown());
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: struct PointerHelpers<DynamicCapability, Kind::OTHER> {
cannam@62: // getDynamic() is used when an AnyPointer's get() accessor is passed arguments, because for
cannam@62: // non-dynamic types PointerHelpers::get() takes a default value as the third argument, and we
cannam@62: // don't want people to accidentally be able to provide their own default value.
cannam@62: static DynamicCapability::Client getDynamic(PointerReader reader, InterfaceSchema schema);
cannam@62: static DynamicCapability::Client getDynamic(PointerBuilder builder, InterfaceSchema schema);
cannam@62: static void set(PointerBuilder builder, DynamicCapability::Client& value);
cannam@62: static void set(PointerBuilder builder, DynamicCapability::Client&& value);
cannam@62: static inline void adopt(PointerBuilder builder, Orphan<DynamicCapability>&& value) {
cannam@62: builder.adopt(kj::mv(value.builder));
cannam@62: }
cannam@62: static inline Orphan<DynamicCapability> disown(PointerBuilder builder, InterfaceSchema schema) {
cannam@62: return Orphan<DynamicCapability>(schema, builder.disown());
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: } // namespace _ (private)
cannam@62:
cannam@62: template <typename T>
cannam@62: inline ReaderFor<T> AnyPointer::Reader::getAs(StructSchema schema) const {
cannam@62: return _::PointerHelpers<T>::getDynamic(reader, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline ReaderFor<T> AnyPointer::Reader::getAs(ListSchema schema) const {
cannam@62: return _::PointerHelpers<T>::getDynamic(reader, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline ReaderFor<T> AnyPointer::Reader::getAs(InterfaceSchema schema) const {
cannam@62: return _::PointerHelpers<T>::getDynamic(reader, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline BuilderFor<T> AnyPointer::Builder::getAs(StructSchema schema) {
cannam@62: return _::PointerHelpers<T>::getDynamic(builder, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline BuilderFor<T> AnyPointer::Builder::getAs(ListSchema schema) {
cannam@62: return _::PointerHelpers<T>::getDynamic(builder, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline BuilderFor<T> AnyPointer::Builder::getAs(InterfaceSchema schema) {
cannam@62: return _::PointerHelpers<T>::getDynamic(builder, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline BuilderFor<T> AnyPointer::Builder::initAs(StructSchema schema) {
cannam@62: return _::PointerHelpers<T>::init(builder, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline BuilderFor<T> AnyPointer::Builder::initAs(ListSchema schema, uint elementCount) {
cannam@62: return _::PointerHelpers<T>::init(builder, schema, elementCount);
cannam@62: }
cannam@62: template <>
cannam@62: inline void AnyPointer::Builder::setAs<DynamicStruct>(DynamicStruct::Reader value) {
cannam@62: return _::PointerHelpers<DynamicStruct>::set(builder, value);
cannam@62: }
cannam@62: template <>
cannam@62: inline void AnyPointer::Builder::setAs<DynamicList>(DynamicList::Reader value) {
cannam@62: return _::PointerHelpers<DynamicList>::set(builder, value);
cannam@62: }
cannam@62: template <>
cannam@62: inline void AnyPointer::Builder::setAs<DynamicCapability>(DynamicCapability::Client value) {
cannam@62: return _::PointerHelpers<DynamicCapability>::set(builder, kj::mv(value));
cannam@62: }
cannam@62: template <>
cannam@62: void AnyPointer::Builder::adopt<DynamicValue>(Orphan<DynamicValue>&& orphan);
cannam@62: template <typename T>
cannam@62: inline Orphan<T> AnyPointer::Builder::disownAs(StructSchema schema) {
cannam@62: return _::PointerHelpers<T>::disown(builder, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline Orphan<T> AnyPointer::Builder::disownAs(ListSchema schema) {
cannam@62: return _::PointerHelpers<T>::disown(builder, schema);
cannam@62: }
cannam@62: template <typename T>
cannam@62: inline Orphan<T> AnyPointer::Builder::disownAs(InterfaceSchema schema) {
cannam@62: return _::PointerHelpers<T>::disown(builder, schema);
cannam@62: }
cannam@62:
cannam@62: // We have to declare the methods below inline because Clang and GCC disagree about how to mangle
cannam@62: // their symbol names.
cannam@62: template <>
cannam@62: inline DynamicStruct::Builder Orphan<AnyPointer>::getAs<DynamicStruct>(StructSchema schema) {
cannam@62: return DynamicStruct::Builder(schema, builder);
cannam@62: }
cannam@62: template <>
cannam@62: inline DynamicStruct::Reader Orphan<AnyPointer>::getAsReader<DynamicStruct>(
cannam@62: StructSchema schema) const {
cannam@62: return DynamicStruct::Reader(schema, builder);
cannam@62: }
cannam@62: template <>
cannam@62: inline Orphan<DynamicStruct> Orphan<AnyPointer>::releaseAs<DynamicStruct>(StructSchema schema) {
cannam@62: return Orphan<DynamicStruct>(schema, kj::mv(builder));
cannam@62: }
cannam@62: template <>
cannam@62: inline DynamicList::Builder Orphan<AnyPointer>::getAs<DynamicList>(ListSchema schema) {
cannam@62: return DynamicList::Builder(schema, builder);
cannam@62: }
cannam@62: template <>
cannam@62: inline DynamicList::Reader Orphan<AnyPointer>::getAsReader<DynamicList>(ListSchema schema) const {
cannam@62: return DynamicList::Reader(schema, builder);
cannam@62: }
cannam@62: template <>
cannam@62: inline Orphan<DynamicList> Orphan<AnyPointer>::releaseAs<DynamicList>(ListSchema schema) {
cannam@62: return Orphan<DynamicList>(schema, kj::mv(builder));
cannam@62: }
cannam@62: template <>
cannam@62: inline DynamicCapability::Client Orphan<AnyPointer>::getAs<DynamicCapability>(
cannam@62: InterfaceSchema schema) {
cannam@62: return DynamicCapability::Client(schema, builder.asCapability());
cannam@62: }
cannam@62: template <>
cannam@62: inline DynamicCapability::Client Orphan<AnyPointer>::getAsReader<DynamicCapability>(
cannam@62: InterfaceSchema schema) const {
cannam@62: return DynamicCapability::Client(schema, builder.asCapability());
cannam@62: }
cannam@62: template <>
cannam@62: inline Orphan<DynamicCapability> Orphan<AnyPointer>::releaseAs<DynamicCapability>(
cannam@62: InterfaceSchema schema) {
cannam@62: return Orphan<DynamicCapability>(schema, kj::mv(builder));
cannam@62: }
cannam@62:
cannam@62: // =======================================================================================
cannam@62: // Inline implementation details.
cannam@62:
cannam@62: template <typename T>
cannam@62: struct ToDynamic_<T, Kind::STRUCT> {
cannam@62: static inline DynamicStruct::Reader apply(const typename T::Reader& value) {
cannam@62: return DynamicStruct::Reader(Schema::from<T>(), value._reader);
cannam@62: }
cannam@62: static inline DynamicStruct::Builder apply(typename T::Builder& value) {
cannam@62: return DynamicStruct::Builder(Schema::from<T>(), value._builder);
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <typename T>
cannam@62: struct ToDynamic_<T, Kind::LIST> {
cannam@62: static inline DynamicList::Reader apply(const typename T::Reader& value) {
cannam@62: return DynamicList::Reader(Schema::from<T>(), value.reader);
cannam@62: }
cannam@62: static inline DynamicList::Builder apply(typename T::Builder& value) {
cannam@62: return DynamicList::Builder(Schema::from<T>(), value.builder);
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <typename T>
cannam@62: struct ToDynamic_<T, Kind::INTERFACE> {
cannam@62: static inline DynamicCapability::Client apply(typename T::Client value) {
cannam@62: return DynamicCapability::Client(kj::mv(value));
cannam@62: }
cannam@62: static inline DynamicCapability::Client apply(typename T::Client&& value) {
cannam@62: return DynamicCapability::Client(kj::mv(value));
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <typename T>
cannam@62: ReaderFor<DynamicTypeFor<FromReader<T>>> toDynamic(T&& value) {
cannam@62: return ToDynamic_<FromReader<T>>::apply(value);
cannam@62: }
cannam@62: template <typename T>
cannam@62: BuilderFor<DynamicTypeFor<FromBuilder<T>>> toDynamic(T&& value) {
cannam@62: return ToDynamic_<FromBuilder<T>>::apply(value);
cannam@62: }
cannam@62: template <typename T>
cannam@62: DynamicTypeFor<TypeIfEnum<T>> toDynamic(T&& value) {
cannam@62: return DynamicEnum(Schema::from<kj::Decay<T>>(), static_cast<uint16_t>(value));
cannam@62: }
cannam@62: template <typename T>
cannam@62: typename DynamicTypeFor<FromServer<T>>::Client toDynamic(kj::Own<T>&& value) {
cannam@62: return typename FromServer<T>::Client(kj::mv(value));
cannam@62: }
cannam@62:
cannam@62: inline DynamicValue::Reader::Reader(std::nullptr_t n): type(UNKNOWN) {}
cannam@62: inline DynamicValue::Builder::Builder(std::nullptr_t n): type(UNKNOWN) {}
cannam@62:
cannam@62: #define CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(cppType, typeTag, fieldName) \
cannam@62: inline DynamicValue::Reader::Reader(cppType value) \
cannam@62: : type(typeTag), fieldName##Value(value) {} \
cannam@62: inline DynamicValue::Builder::Builder(cppType value) \
cannam@62: : type(typeTag), fieldName##Value(value) {} \
cannam@62: inline Orphan<DynamicValue>::Orphan(cppType value) \
cannam@62: : type(DynamicValue::typeTag), fieldName##Value(value) {}
cannam@62:
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(Void, VOID, void);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(bool, BOOL, bool);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(char, INT, int);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(signed char, INT, int);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(short, INT, int);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(int, INT, int);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(long, INT, int);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(long long, INT, int);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(unsigned char, UINT, uint);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(unsigned short, UINT, uint);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(unsigned int, UINT, uint);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(unsigned long, UINT, uint);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(unsigned long long, UINT, uint);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(float, FLOAT, float);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(double, FLOAT, float);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(DynamicEnum, ENUM, enum);
cannam@62: #undef CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR
cannam@62:
cannam@62: #define CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(cppType, typeTag, fieldName) \
cannam@62: inline DynamicValue::Reader::Reader(const cppType::Reader& value) \
cannam@62: : type(typeTag), fieldName##Value(value) {} \
cannam@62: inline DynamicValue::Builder::Builder(cppType::Builder value) \
cannam@62: : type(typeTag), fieldName##Value(value) {}
cannam@62:
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(Text, TEXT, text);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(Data, DATA, data);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(DynamicList, LIST, list);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(DynamicStruct, STRUCT, struct);
cannam@62: CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR(AnyPointer, ANY_POINTER, anyPointer);
cannam@62:
cannam@62: #undef CAPNP_DECLARE_DYNAMIC_VALUE_CONSTRUCTOR
cannam@62:
cannam@62: inline DynamicValue::Reader::Reader(DynamicCapability::Client& value)
cannam@62: : type(CAPABILITY), capabilityValue(value) {}
cannam@62: inline DynamicValue::Reader::Reader(DynamicCapability::Client&& value)
cannam@62: : type(CAPABILITY), capabilityValue(kj::mv(value)) {}
cannam@62: template <typename T, typename>
cannam@62: inline DynamicValue::Reader::Reader(kj::Own<T>&& value)
cannam@62: : type(CAPABILITY), capabilityValue(kj::mv(value)) {}
cannam@62: inline DynamicValue::Builder::Builder(DynamicCapability::Client& value)
cannam@62: : type(CAPABILITY), capabilityValue(value) {}
cannam@62: inline DynamicValue::Builder::Builder(DynamicCapability::Client&& value)
cannam@62: : type(CAPABILITY), capabilityValue(kj::mv(value)) {}
cannam@62:
cannam@62: inline DynamicValue::Reader::Reader(const char* value): Reader(Text::Reader(value)) {}
cannam@62:
cannam@62: #define CAPNP_DECLARE_TYPE(discrim, typeName) \
cannam@62: template <> \
cannam@62: struct DynamicValue::Reader::AsImpl<typeName> { \
cannam@62: static ReaderFor<typeName> apply(const Reader& reader); \
cannam@62: }; \
cannam@62: template <> \
cannam@62: struct DynamicValue::Builder::AsImpl<typeName> { \
cannam@62: static BuilderFor<typeName> apply(Builder& builder); \
cannam@62: };
cannam@62:
cannam@62: //CAPNP_DECLARE_TYPE(VOID, Void)
cannam@62: CAPNP_DECLARE_TYPE(BOOL, bool)
cannam@62: CAPNP_DECLARE_TYPE(INT8, int8_t)
cannam@62: CAPNP_DECLARE_TYPE(INT16, int16_t)
cannam@62: CAPNP_DECLARE_TYPE(INT32, int32_t)
cannam@62: CAPNP_DECLARE_TYPE(INT64, int64_t)
cannam@62: CAPNP_DECLARE_TYPE(UINT8, uint8_t)
cannam@62: CAPNP_DECLARE_TYPE(UINT16, uint16_t)
cannam@62: CAPNP_DECLARE_TYPE(UINT32, uint32_t)
cannam@62: CAPNP_DECLARE_TYPE(UINT64, uint64_t)
cannam@62: CAPNP_DECLARE_TYPE(FLOAT32, float)
cannam@62: CAPNP_DECLARE_TYPE(FLOAT64, double)
cannam@62:
cannam@62: CAPNP_DECLARE_TYPE(TEXT, Text)
cannam@62: CAPNP_DECLARE_TYPE(DATA, Data)
cannam@62: CAPNP_DECLARE_TYPE(LIST, DynamicList)
cannam@62: CAPNP_DECLARE_TYPE(STRUCT, DynamicStruct)
cannam@62: CAPNP_DECLARE_TYPE(INTERFACE, DynamicCapability)
cannam@62: CAPNP_DECLARE_TYPE(ENUM, DynamicEnum)
cannam@62: CAPNP_DECLARE_TYPE(ANY_POINTER, AnyPointer)
cannam@62: #undef CAPNP_DECLARE_TYPE
cannam@62:
cannam@62: // CAPNP_DECLARE_TYPE(Void) causes gcc 4.7 to segfault. If I do it manually and remove the
cannam@62: // ReaderFor<> and BuilderFor<> wrappers, it works.
cannam@62: template <>
cannam@62: struct DynamicValue::Reader::AsImpl<Void> {
cannam@62: static Void apply(const Reader& reader);
cannam@62: };
cannam@62: template <>
cannam@62: struct DynamicValue::Builder::AsImpl<Void> {
cannam@62: static Void apply(Builder& builder);
cannam@62: };
cannam@62:
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Reader::AsImpl<T, Kind::ENUM> {
cannam@62: static T apply(const Reader& reader) {
cannam@62: return reader.as<DynamicEnum>().as<T>();
cannam@62: }
cannam@62: };
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Builder::AsImpl<T, Kind::ENUM> {
cannam@62: static T apply(Builder& builder) {
cannam@62: return builder.as<DynamicEnum>().as<T>();
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Reader::AsImpl<T, Kind::STRUCT> {
cannam@62: static typename T::Reader apply(const Reader& reader) {
cannam@62: return reader.as<DynamicStruct>().as<T>();
cannam@62: }
cannam@62: };
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Builder::AsImpl<T, Kind::STRUCT> {
cannam@62: static typename T::Builder apply(Builder& builder) {
cannam@62: return builder.as<DynamicStruct>().as<T>();
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Reader::AsImpl<T, Kind::LIST> {
cannam@62: static typename T::Reader apply(const Reader& reader) {
cannam@62: return reader.as<DynamicList>().as<T>();
cannam@62: }
cannam@62: };
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Builder::AsImpl<T, Kind::LIST> {
cannam@62: static typename T::Builder apply(Builder& builder) {
cannam@62: return builder.as<DynamicList>().as<T>();
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Reader::AsImpl<T, Kind::INTERFACE> {
cannam@62: static typename T::Client apply(const Reader& reader) {
cannam@62: return reader.as<DynamicCapability>().as<T>();
cannam@62: }
cannam@62: };
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Builder::AsImpl<T, Kind::INTERFACE> {
cannam@62: static typename T::Client apply(Builder& builder) {
cannam@62: return builder.as<DynamicCapability>().as<T>();
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: template <>
cannam@62: struct DynamicValue::Reader::AsImpl<DynamicValue> {
cannam@62: static DynamicValue::Reader apply(const Reader& reader) {
cannam@62: return reader;
cannam@62: }
cannam@62: };
cannam@62: template <>
cannam@62: struct DynamicValue::Builder::AsImpl<DynamicValue> {
cannam@62: static DynamicValue::Builder apply(Builder& builder) {
cannam@62: return builder;
cannam@62: }
cannam@62: };
cannam@62:
cannam@62: inline DynamicValue::Pipeline::Pipeline(std::nullptr_t n): type(UNKNOWN) {}
cannam@62: inline DynamicValue::Pipeline::Pipeline(DynamicStruct::Pipeline&& value)
cannam@62: : type(STRUCT), structValue(kj::mv(value)) {}
cannam@62: inline DynamicValue::Pipeline::Pipeline(DynamicCapability::Client&& value)
cannam@62: : type(CAPABILITY), capabilityValue(kj::mv(value)) {}
cannam@62:
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Pipeline::AsImpl<T, Kind::STRUCT> {
cannam@62: static typename T::Pipeline apply(Pipeline& pipeline) {
cannam@62: return pipeline.releaseAs<DynamicStruct>().releaseAs<T>();
cannam@62: }
cannam@62: };
cannam@62: template <typename T>
cannam@62: struct DynamicValue::Pipeline::AsImpl<T, Kind::INTERFACE> {
cannam@62: static typename T::Client apply(Pipeline& pipeline) {
cannam@62: return pipeline.releaseAs<DynamicCapability>().releaseAs<T>();
cannam@62: }
cannam@62: };
cannam@62: template <>
cannam@62: struct DynamicValue::Pipeline::AsImpl<DynamicStruct, Kind::OTHER> {
cannam@62: static PipelineFor<DynamicStruct> apply(Pipeline& pipeline);
cannam@62: };
cannam@62: template <>
cannam@62: struct DynamicValue::Pipeline::AsImpl<DynamicCapability, Kind::OTHER> {
cannam@62: static PipelineFor<DynamicCapability> apply(Pipeline& pipeline);
cannam@62: };
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Reader DynamicStruct::Reader::as() const {
cannam@62: static_assert(kind<T>() == Kind::STRUCT,
cannam@62: "DynamicStruct::Reader::as<T>() can only convert to struct types.");
cannam@62: schema.requireUsableAs<T>();
cannam@62: return typename T::Reader(reader);
cannam@62: }
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Builder DynamicStruct::Builder::as() {
cannam@62: static_assert(kind<T>() == Kind::STRUCT,
cannam@62: "DynamicStruct::Builder::as<T>() can only convert to struct types.");
cannam@62: schema.requireUsableAs<T>();
cannam@62: return typename T::Builder(builder);
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline DynamicStruct::Reader DynamicStruct::Reader::as<DynamicStruct>() const {
cannam@62: return *this;
cannam@62: }
cannam@62: template <>
cannam@62: inline DynamicStruct::Builder DynamicStruct::Builder::as<DynamicStruct>() {
cannam@62: return *this;
cannam@62: }
cannam@62:
cannam@62: inline DynamicStruct::Reader DynamicStruct::Builder::asReader() const {
cannam@62: return DynamicStruct::Reader(schema, builder.asReader());
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline AnyStruct::Reader DynamicStruct::Reader::as<AnyStruct>() const {
cannam@62: return AnyStruct::Reader(reader);
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline AnyStruct::Builder DynamicStruct::Builder::as<AnyStruct>() {
cannam@62: return AnyStruct::Builder(builder);
cannam@62: }
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Pipeline DynamicStruct::Pipeline::releaseAs() {
cannam@62: static_assert(kind<T>() == Kind::STRUCT,
cannam@62: "DynamicStruct::Pipeline::releaseAs<T>() can only convert to struct types.");
cannam@62: schema.requireUsableAs<T>();
cannam@62: return typename T::Pipeline(kj::mv(typeless));
cannam@62: }
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: template <typename T>
cannam@62: typename T::Reader DynamicList::Reader::as() const {
cannam@62: static_assert(kind<T>() == Kind::LIST,
cannam@62: "DynamicStruct::Reader::as<T>() can only convert to list types.");
cannam@62: schema.requireUsableAs<T>();
cannam@62: return typename T::Reader(reader);
cannam@62: }
cannam@62: template <typename T>
cannam@62: typename T::Builder DynamicList::Builder::as() {
cannam@62: static_assert(kind<T>() == Kind::LIST,
cannam@62: "DynamicStruct::Builder::as<T>() can only convert to list types.");
cannam@62: schema.requireUsableAs<T>();
cannam@62: return typename T::Builder(builder);
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline DynamicList::Reader DynamicList::Reader::as<DynamicList>() const {
cannam@62: return *this;
cannam@62: }
cannam@62: template <>
cannam@62: inline DynamicList::Builder DynamicList::Builder::as<DynamicList>() {
cannam@62: return *this;
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline AnyList::Reader DynamicList::Reader::as<AnyList>() const {
cannam@62: return AnyList::Reader(reader);
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline AnyList::Builder DynamicList::Builder::as<AnyList>() {
cannam@62: return AnyList::Builder(builder);
cannam@62: }
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: template <typename T, typename>
cannam@62: inline DynamicCapability::Client::Client(T&& client)
cannam@62: : Capability::Client(kj::mv(client)), schema(Schema::from<FromClient<T>>()) {}
cannam@62:
cannam@62: template <typename T, typename>
cannam@62: inline DynamicCapability::Client::Client(kj::Own<T>&& server)
cannam@62: : Client(server->getSchema(), kj::mv(server)) {}
cannam@62: template <typename T>
cannam@62: inline DynamicCapability::Client::Client(InterfaceSchema schema, kj::Own<T>&& server)
cannam@62: : Capability::Client(kj::mv(server)), schema(schema) {}
cannam@62:
cannam@62: template <typename T, typename>
cannam@62: typename T::Client DynamicCapability::Client::as() {
cannam@62: static_assert(kind<T>() == Kind::INTERFACE,
cannam@62: "DynamicCapability::Client::as<T>() can only convert to interface types.");
cannam@62: schema.requireUsableAs<T>();
cannam@62: return typename T::Client(hook->addRef());
cannam@62: }
cannam@62:
cannam@62: template <typename T, typename>
cannam@62: typename T::Client DynamicCapability::Client::releaseAs() {
cannam@62: static_assert(kind<T>() == Kind::INTERFACE,
cannam@62: "DynamicCapability::Client::as<T>() can only convert to interface types.");
cannam@62: schema.requireUsableAs<T>();
cannam@62: return typename T::Client(kj::mv(hook));
cannam@62: }
cannam@62:
cannam@62: inline CallContext<DynamicStruct, DynamicStruct>::CallContext(
cannam@62: CallContextHook& hook, StructSchema paramType, StructSchema resultType)
cannam@62: : hook(&hook), paramType(paramType), resultType(resultType) {}
cannam@62: inline DynamicStruct::Reader CallContext<DynamicStruct, DynamicStruct>::getParams() {
cannam@62: return hook->getParams().getAs<DynamicStruct>(paramType);
cannam@62: }
cannam@62: inline void CallContext<DynamicStruct, DynamicStruct>::releaseParams() {
cannam@62: hook->releaseParams();
cannam@62: }
cannam@62: inline DynamicStruct::Builder CallContext<DynamicStruct, DynamicStruct>::getResults(
cannam@62: kj::Maybe<MessageSize> sizeHint) {
cannam@62: return hook->getResults(sizeHint).getAs<DynamicStruct>(resultType);
cannam@62: }
cannam@62: inline DynamicStruct::Builder CallContext<DynamicStruct, DynamicStruct>::initResults(
cannam@62: kj::Maybe<MessageSize> sizeHint) {
cannam@62: return hook->getResults(sizeHint).initAs<DynamicStruct>(resultType);
cannam@62: }
cannam@62: inline void CallContext<DynamicStruct, DynamicStruct>::setResults(DynamicStruct::Reader value) {
cannam@62: hook->getResults(value.totalSize()).setAs<DynamicStruct>(value);
cannam@62: }
cannam@62: inline void CallContext<DynamicStruct, DynamicStruct>::adoptResults(Orphan<DynamicStruct>&& value) {
cannam@62: hook->getResults(MessageSize { 0, 0 }).adopt(kj::mv(value));
cannam@62: }
cannam@62: inline Orphanage CallContext<DynamicStruct, DynamicStruct>::getResultsOrphanage(
cannam@62: kj::Maybe<MessageSize> sizeHint) {
cannam@62: return Orphanage::getForMessageContaining(hook->getResults(sizeHint));
cannam@62: }
cannam@62: template <typename SubParams>
cannam@62: inline kj::Promise<void> CallContext<DynamicStruct, DynamicStruct>::tailCall(
cannam@62: Request<SubParams, DynamicStruct>&& tailRequest) {
cannam@62: return hook->tailCall(kj::mv(tailRequest.hook));
cannam@62: }
cannam@62: inline void CallContext<DynamicStruct, DynamicStruct>::allowCancellation() {
cannam@62: hook->allowCancellation();
cannam@62: }
cannam@62:
cannam@62: template <>
cannam@62: inline DynamicCapability::Client Capability::Client::castAs<DynamicCapability>(
cannam@62: InterfaceSchema schema) {
cannam@62: return DynamicCapability::Client(schema, hook->addRef());
cannam@62: }
cannam@62:
cannam@62: // -------------------------------------------------------------------
cannam@62:
cannam@62: template <typename T>
cannam@62: ReaderFor<T> ConstSchema::as() const {
cannam@62: return DynamicValue::Reader(*this).as<T>();
cannam@62: }
cannam@62:
cannam@62: } // namespace capnp
cannam@62:
cannam@62: #endif // CAPNP_DYNAMIC_H_