comparison osx/include/capnp/dynamic.h @ 147:45360b968bf4

Cap'n Proto v0.6 + build for OSX

   StructSchema schema;
   _::StructReader reader;
 
   inline Reader(StructSchema schema, _::StructReader reader)
       : schema(schema), reader(reader) {}
+  Reader(StructSchema schema, const _::OrphanBuilder& orphan);
 
   bool isSetInUnion(StructSchema::Field field) const;
   void verifySetInUnion(StructSchema::Field field) const;
   static DynamicValue::Reader getImpl(_::StructReader reader, StructSchema::Field field);
 

   StructSchema schema;
   _::StructBuilder builder;
 
   inline Builder(StructSchema schema, _::StructBuilder builder)
       : schema(schema), builder(builder) {}
+  Builder(StructSchema schema, _::OrphanBuilder& orphan);
 
   bool isSetInUnion(StructSchema::Field field);
   void verifySetInUnion(StructSchema::Field field);
   void setInUnion(StructSchema::Field field);
 

   // Try to convert to any List<T>, Data, or Text.  Throws an exception if the underlying data
   // can't possibly represent the requested type.
 
   inline ListSchema getSchema() const { return schema; }
 
-  inline uint size() const { return reader.size() / ELEMENTS; }
+  inline uint size() const { return unbound(reader.size() / ELEMENTS); }
   DynamicValue::Reader operator[](uint index) const;
 
   typedef _::IndexingIterator<const Reader, DynamicValue::Reader> Iterator;
   inline Iterator begin() const { return Iterator(this, 0); }
   inline Iterator end() const { return Iterator(this, size()); }

 private:
   ListSchema schema;
   _::ListReader reader;
 
   Reader(ListSchema schema, _::ListReader reader): schema(schema), reader(reader) {}
+  Reader(ListSchema schema, const _::OrphanBuilder& orphan);
 
   template <typename T, Kind k>
   friend struct _::PointerHelpers;
   friend struct DynamicStruct;
   friend class DynamicList::Builder;

   // Try to convert to any List<T>, Data, or Text.  Throws an exception if the underlying data
   // can't possibly represent the requested type.
 
   inline ListSchema getSchema() const { return schema; }
 
-  inline uint size() const { return builder.size() / ELEMENTS; }
+  inline uint size() const { return unbound(builder.size() / ELEMENTS); }
   DynamicValue::Builder operator[](uint index);
   void set(uint index, const DynamicValue::Reader& value);
   DynamicValue::Builder init(uint index, uint size);
   void adopt(uint index, Orphan<DynamicValue>&& orphan);
   Orphan<DynamicValue> disown(uint index);

 private:
   ListSchema schema;
   _::ListBuilder builder;
 
   Builder(ListSchema schema, _::ListBuilder builder): schema(schema), builder(builder) {}
+  Builder(ListSchema schema, _::OrphanBuilder& orphan);
 
   template <typename T, Kind k>
   friend struct _::PointerHelpers;
   friend struct DynamicStruct;
   template <typename T, ::capnp::Kind k>

   // - Text, Data, AnyPointer, any struct type:  Returns the corresponding Reader.
   // - List<T> for any T listed above:  Returns List<T>::Reader.
   // - DynamicEnum:  Returns the corresponding type.
   // - DynamicStruct, DynamicList:  Returns the corresponding Reader.
   // - Any capability type, including DynamicCapability:  Returns the corresponding Client.
+  // - DynamicValue:  Returns an identical Reader. Useful to avoid special-casing in generic code.
   //   (TODO(perf):  On GCC 4.8 / Clang 3.3, provide rvalue-qualified version that avoids
   //   refcounting.)
   //
   // DynamicValue allows various implicit conversions, mostly just to make the interface friendlier.
   // - Any integer can be converted to any other integer type so long as the actual value is within

 template <typename T>
 inline Orphan<T> AnyPointer::Builder::disownAs(InterfaceSchema schema) {
   return _::PointerHelpers<T>::disown(builder, schema);
 }
 
-template <>
-DynamicStruct::Builder Orphan<AnyPointer>::getAs<DynamicStruct>(StructSchema schema);
-template <>
-DynamicList::Builder Orphan<AnyPointer>::getAs<DynamicList>(ListSchema schema);
-template <>
-DynamicCapability::Client Orphan<AnyPointer>::getAs<DynamicCapability>(InterfaceSchema schema);
-template <>
-DynamicStruct::Reader Orphan<AnyPointer>::getAsReader<DynamicStruct>(StructSchema schema) const;
-template <>
-DynamicList::Reader Orphan<AnyPointer>::getAsReader<DynamicList>(ListSchema schema) const;
-template <>
-DynamicCapability::Client Orphan<AnyPointer>::getAsReader<DynamicCapability>(
-    InterfaceSchema schema) const;
-template <>
-Orphan<DynamicStruct> Orphan<AnyPointer>::releaseAs<DynamicStruct>(StructSchema schema);
-template <>
-Orphan<DynamicList> Orphan<AnyPointer>::releaseAs<DynamicList>(ListSchema schema);
-template <>
-Orphan<DynamicCapability> Orphan<AnyPointer>::releaseAs<DynamicCapability>(
-    InterfaceSchema schema);
+// We have to declare the methods below inline because Clang and GCC disagree about how to mangle
+// their symbol names.
+template <>
+inline DynamicStruct::Builder Orphan<AnyPointer>::getAs<DynamicStruct>(StructSchema schema) {
+  return DynamicStruct::Builder(schema, builder);
+}
+template <>
+inline DynamicStruct::Reader Orphan<AnyPointer>::getAsReader<DynamicStruct>(
+    StructSchema schema) const {
+  return DynamicStruct::Reader(schema, builder);
+}
+template <>
+inline Orphan<DynamicStruct> Orphan<AnyPointer>::releaseAs<DynamicStruct>(StructSchema schema) {
+  return Orphan<DynamicStruct>(schema, kj::mv(builder));
+}
+template <>
+inline DynamicList::Builder Orphan<AnyPointer>::getAs<DynamicList>(ListSchema schema) {
+  return DynamicList::Builder(schema, builder);
+}
+template <>
+inline DynamicList::Reader Orphan<AnyPointer>::getAsReader<DynamicList>(ListSchema schema) const {
+  return DynamicList::Reader(schema, builder);
+}
+template <>
+inline Orphan<DynamicList> Orphan<AnyPointer>::releaseAs<DynamicList>(ListSchema schema) {
+  return Orphan<DynamicList>(schema, kj::mv(builder));
+}
+template <>
+inline DynamicCapability::Client Orphan<AnyPointer>::getAs<DynamicCapability>(
+    InterfaceSchema schema) {
+  return DynamicCapability::Client(schema, builder.asCapability());
+}
+template <>
+inline DynamicCapability::Client Orphan<AnyPointer>::getAsReader<DynamicCapability>(
+    InterfaceSchema schema) const {
+  return DynamicCapability::Client(schema, builder.asCapability());
+}
+template <>
+inline Orphan<DynamicCapability> Orphan<AnyPointer>::releaseAs<DynamicCapability>(
+    InterfaceSchema schema) {
+  return Orphan<DynamicCapability>(schema, kj::mv(builder));
+}
 
 // =======================================================================================
 // Inline implementation details.
 
 template <typename T>

   static typename T::Client apply(Builder& builder) {
     return builder.as<DynamicCapability>().as<T>();
   }
 };
 
+template <>
+struct DynamicValue::Reader::AsImpl<DynamicValue> {
+  static DynamicValue::Reader apply(const Reader& reader) {
+    return reader;
+  }
+};
+template <>
+struct DynamicValue::Builder::AsImpl<DynamicValue> {
+  static DynamicValue::Builder apply(Builder& builder) {
+    return builder;
+  }
+};
+
 inline DynamicValue::Pipeline::Pipeline(std::nullptr_t n): type(UNKNOWN) {}
 inline DynamicValue::Pipeline::Pipeline(DynamicStruct::Pipeline&& value)
     : type(STRUCT), structValue(kj::mv(value)) {}
 inline DynamicValue::Pipeline::Pipeline(DynamicCapability::Client&& value)
     : type(CAPABILITY), capabilityValue(kj::mv(value)) {}

   return *this;
 }
 template <>
 inline DynamicList::Builder DynamicList::Builder::as<DynamicList>() {
   return *this;
+}
+
+template <>
+inline AnyList::Reader DynamicList::Reader::as<AnyList>() const {
+  return AnyList::Reader(reader);
+}
+
+template <>
+inline AnyList::Builder DynamicList::Builder::as<AnyList>() {
+  return AnyList::Builder(builder);
 }
 
 // -------------------------------------------------------------------
 
 template <typename T, typename>