cannam@49: // Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
cannam@49: // Licensed under the MIT License:
cannam@49: //
cannam@49: // Permission is hereby granted, free of charge, to any person obtaining a copy
cannam@49: // of this software and associated documentation files (the "Software"), to deal
cannam@49: // in the Software without restriction, including without limitation the rights
cannam@49: // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
cannam@49: // copies of the Software, and to permit persons to whom the Software is
cannam@49: // furnished to do so, subject to the following conditions:
cannam@49: //
cannam@49: // The above copyright notice and this permission notice shall be included in
cannam@49: // all copies or substantial portions of the Software.
cannam@49: //
cannam@49: // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
cannam@49: // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
cannam@49: // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
cannam@49: // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
cannam@49: // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
cannam@49: // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
cannam@49: // THE SOFTWARE.
cannam@49: 
cannam@49: #ifndef CAPNP_LIST_H_
cannam@49: #define CAPNP_LIST_H_
cannam@49: 
cannam@49: #if defined(__GNUC__) && !defined(CAPNP_HEADER_WARNINGS)
cannam@49: #pragma GCC system_header
cannam@49: #endif
cannam@49: 
cannam@49: #include "layout.h"
cannam@49: #include "orphan.h"
cannam@49: #include <initializer_list>
cannam@49: #ifdef KJ_STD_COMPAT
cannam@49: #include <iterator>
cannam@49: #endif  // KJ_STD_COMPAT
cannam@49: 
cannam@49: namespace capnp {
cannam@49: namespace _ {  // private
cannam@49: 
cannam@49: template <typename T>
cannam@49: class TemporaryPointer {
cannam@49:   // This class is a little hack which lets us define operator->() in cases where it needs to
cannam@49:   // return a pointer to a temporary value.  We instead construct a TemporaryPointer and return that
cannam@49:   // (by value).  The compiler then invokes operator->() on the TemporaryPointer, which itself is
cannam@49:   // able to return a real pointer to its member.
cannam@49: 
cannam@49: public:
cannam@49:   TemporaryPointer(T&& value): value(kj::mv(value)) {}
cannam@49:   TemporaryPointer(const T& value): value(value) {}
cannam@49: 
cannam@49:   inline T* operator->() { return &value; }
cannam@49: private:
cannam@49:   T value;
cannam@49: };
cannam@49: 
cannam@49: template <typename Container, typename Element>
cannam@49: class IndexingIterator {
cannam@49: public:
cannam@49:   IndexingIterator() = default;
cannam@49: 
cannam@49:   inline Element operator*() const { return (*container)[index]; }
cannam@49:   inline TemporaryPointer<Element> operator->() const {
cannam@49:     return TemporaryPointer<Element>((*container)[index]);
cannam@49:   }
cannam@49:   inline Element operator[]( int off) const { return (*container)[index]; }
cannam@49:   inline Element operator[](uint off) const { return (*container)[index]; }
cannam@49: 
cannam@49:   inline IndexingIterator& operator++() { ++index; return *this; }
cannam@49:   inline IndexingIterator operator++(int) { IndexingIterator other = *this; ++index; return other; }
cannam@49:   inline IndexingIterator& operator--() { --index; return *this; }
cannam@49:   inline IndexingIterator operator--(int) { IndexingIterator other = *this; --index; return other; }
cannam@49: 
cannam@49:   inline IndexingIterator operator+(uint amount) const { return IndexingIterator(container, index + amount); }
cannam@49:   inline IndexingIterator operator-(uint amount) const { return IndexingIterator(container, index - amount); }
cannam@49:   inline IndexingIterator operator+( int amount) const { return IndexingIterator(container, index + amount); }
cannam@49:   inline IndexingIterator operator-( int amount) const { return IndexingIterator(container, index - amount); }
cannam@49: 
cannam@49:   inline int operator-(const IndexingIterator& other) const { return index - other.index; }
cannam@49: 
cannam@49:   inline IndexingIterator& operator+=(uint amount) { index += amount; return *this; }
cannam@49:   inline IndexingIterator& operator-=(uint amount) { index -= amount; return *this; }
cannam@49:   inline IndexingIterator& operator+=( int amount) { index += amount; return *this; }
cannam@49:   inline IndexingIterator& operator-=( int amount) { index -= amount; return *this; }
cannam@49: 
cannam@49:   // STL says comparing iterators of different containers is not allowed, so we only compare
cannam@49:   // indices here.
cannam@49:   inline bool operator==(const IndexingIterator& other) const { return index == other.index; }
cannam@49:   inline bool operator!=(const IndexingIterator& other) const { return index != other.index; }
cannam@49:   inline bool operator<=(const IndexingIterator& other) const { return index <= other.index; }
cannam@49:   inline bool operator>=(const IndexingIterator& other) const { return index >= other.index; }
cannam@49:   inline bool operator< (const IndexingIterator& other) const { return index <  other.index; }
cannam@49:   inline bool operator> (const IndexingIterator& other) const { return index >  other.index; }
cannam@49: 
cannam@49: private:
cannam@49:   Container* container;
cannam@49:   uint index;
cannam@49: 
cannam@49:   friend Container;
cannam@49:   inline IndexingIterator(Container* container, uint index)
cannam@49:       : container(container), index(index) {}
cannam@49: };
cannam@49: 
cannam@49: }  // namespace _ (private)
cannam@49: 
cannam@49: template <typename T>
cannam@49: struct List<T, Kind::PRIMITIVE> {
cannam@49:   // List of primitives.
cannam@49: 
cannam@49:   List() = delete;
cannam@49: 
cannam@49:   class Reader {
cannam@49:   public:
cannam@49:     typedef List<T> Reads;
cannam@49: 
cannam@49:     inline Reader(): reader(_::elementSizeForType<T>()) {}
cannam@49:     inline explicit Reader(_::ListReader reader): reader(reader) {}
cannam@49: 
cannam@49:     inline uint size() const { return reader.size() / ELEMENTS; }
cannam@49:     inline T operator[](uint index) const {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return reader.template getDataElement<T>(index * ELEMENTS);
cannam@49:     }
cannam@49: 
cannam@49:     typedef _::IndexingIterator<const Reader, T> Iterator;
cannam@49:     inline Iterator begin() const { return Iterator(this, 0); }
cannam@49:     inline Iterator end() const { return Iterator(this, size()); }
cannam@49: 
cannam@49:   private:
cannam@49:     _::ListReader reader;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct _::PointerHelpers;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct List;
cannam@49:     friend class Orphanage;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct ToDynamic_;
cannam@49:   };
cannam@49: 
cannam@49:   class Builder {
cannam@49:   public:
cannam@49:     typedef List<T> Builds;
cannam@49: 
cannam@49:     inline Builder(): builder(_::elementSizeForType<T>()) {}
cannam@49:     inline Builder(decltype(nullptr)) {}
cannam@49:     inline explicit Builder(_::ListBuilder builder): builder(builder) {}
cannam@49: 
cannam@49:     inline operator Reader() const { return Reader(builder.asReader()); }
cannam@49:     inline Reader asReader() const { return Reader(builder.asReader()); }
cannam@49: 
cannam@49:     inline uint size() const { return builder.size() / ELEMENTS; }
cannam@49:     inline T operator[](uint index) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return builder.template getDataElement<T>(index * ELEMENTS);
cannam@49:     }
cannam@49:     inline void set(uint index, T value) {
cannam@49:       // Alas, it is not possible to make operator[] return a reference to which you can assign,
cannam@49:       // since the encoded representation does not necessarily match the compiler's representation
cannam@49:       // of the type.  We can't even return a clever class that implements operator T() and
cannam@49:       // operator=() because it will lead to surprising behavior when using type inference (e.g.
cannam@49:       // calling a template function with inferred argument types, or using "auto" or "decltype").
cannam@49: 
cannam@49:       builder.template setDataElement<T>(index * ELEMENTS, value);
cannam@49:     }
cannam@49: 
cannam@49:     typedef _::IndexingIterator<Builder, T> Iterator;
cannam@49:     inline Iterator begin() { return Iterator(this, 0); }
cannam@49:     inline Iterator end() { return Iterator(this, size()); }
cannam@49: 
cannam@49:   private:
cannam@49:     _::ListBuilder builder;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct _::PointerHelpers;
cannam@49:     friend class Orphanage;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct ToDynamic_;
cannam@49:   };
cannam@49: 
cannam@49:   class Pipeline {};
cannam@49: 
cannam@49: private:
cannam@49:   inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
cannam@49:     return builder.initList(_::elementSizeForType<T>(), size * ELEMENTS);
cannam@49:   }
cannam@49:   inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
cannam@49:     return builder.getList(_::elementSizeForType<T>(), defaultValue);
cannam@49:   }
cannam@49:   inline static _::ListReader getFromPointer(
cannam@49:       const _::PointerReader& reader, const word* defaultValue) {
cannam@49:     return reader.getList(_::elementSizeForType<T>(), defaultValue);
cannam@49:   }
cannam@49: 
cannam@49:   template <typename U, Kind k>
cannam@49:   friend struct List;
cannam@49:   template <typename U, Kind K>
cannam@49:   friend struct _::PointerHelpers;
cannam@49: };
cannam@49: 
cannam@49: template <typename T>
cannam@49: struct List<T, Kind::ENUM>: public List<T, Kind::PRIMITIVE> {};
cannam@49: 
cannam@49: template <typename T>
cannam@49: struct List<T, Kind::STRUCT> {
cannam@49:   // List of structs.
cannam@49: 
cannam@49:   List() = delete;
cannam@49: 
cannam@49:   class Reader {
cannam@49:   public:
cannam@49:     typedef List<T> Reads;
cannam@49: 
cannam@49:     inline Reader(): reader(ElementSize::INLINE_COMPOSITE) {}
cannam@49:     inline explicit Reader(_::ListReader reader): reader(reader) {}
cannam@49: 
cannam@49:     inline uint size() const { return reader.size() / ELEMENTS; }
cannam@49:     inline typename T::Reader operator[](uint index) const {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return typename T::Reader(reader.getStructElement(index * ELEMENTS));
cannam@49:     }
cannam@49: 
cannam@49:     typedef _::IndexingIterator<const Reader, typename T::Reader> Iterator;
cannam@49:     inline Iterator begin() const { return Iterator(this, 0); }
cannam@49:     inline Iterator end() const { return Iterator(this, size()); }
cannam@49: 
cannam@49:   private:
cannam@49:     _::ListReader reader;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct _::PointerHelpers;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct List;
cannam@49:     friend class Orphanage;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct ToDynamic_;
cannam@49:   };
cannam@49: 
cannam@49:   class Builder {
cannam@49:   public:
cannam@49:     typedef List<T> Builds;
cannam@49: 
cannam@49:     inline Builder(): builder(ElementSize::INLINE_COMPOSITE) {}
cannam@49:     inline Builder(decltype(nullptr)) {}
cannam@49:     inline explicit Builder(_::ListBuilder builder): builder(builder) {}
cannam@49: 
cannam@49:     inline operator Reader() const { return Reader(builder.asReader()); }
cannam@49:     inline Reader asReader() const { return Reader(builder.asReader()); }
cannam@49: 
cannam@49:     inline uint size() const { return builder.size() / ELEMENTS; }
cannam@49:     inline typename T::Builder operator[](uint index) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return typename T::Builder(builder.getStructElement(index * ELEMENTS));
cannam@49:     }
cannam@49: 
cannam@49:     inline void adoptWithCaveats(uint index, Orphan<T>&& orphan) {
cannam@49:       // Mostly behaves like you'd expect `adopt` to behave, but with two caveats originating from
cannam@49:       // the fact that structs in a struct list are allocated inline rather than by pointer:
cannam@49:       // * This actually performs a shallow copy, effectively adopting each of the orphan's
cannam@49:       //   children rather than adopting the orphan itself.  The orphan ends up being discarded,
cannam@49:       //   possibly wasting space in the message object.
cannam@49:       // * If the orphan is larger than the target struct -- say, because the orphan was built
cannam@49:       //   using a newer version of the schema that has additional fields -- it will be truncated,
cannam@49:       //   losing data.
cannam@49: 
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49: 
cannam@49:       // We pass a zero-valued StructSize to asStruct() because we do not want the struct to be
cannam@49:       // expanded under any circumstances.  We're just going to throw it away anyway, and
cannam@49:       // transferContentFrom() already carefully compares the struct sizes before transferring.
cannam@49:       builder.getStructElement(index * ELEMENTS).transferContentFrom(
cannam@49:           orphan.builder.asStruct(_::StructSize(0 * WORDS, 0 * POINTERS)));
cannam@49:     }
cannam@49:     inline void setWithCaveats(uint index, const typename T::Reader& reader) {
cannam@49:       // Mostly behaves like you'd expect `set` to behave, but with a caveat originating from
cannam@49:       // the fact that structs in a struct list are allocated inline rather than by pointer:
cannam@49:       // If the source struct is larger than the target struct -- say, because the source was built
cannam@49:       // using a newer version of the schema that has additional fields -- it will be truncated,
cannam@49:       // losing data.
cannam@49:       //
cannam@49:       // Note: If you are trying to concatenate some lists, use Orphanage::newOrphanConcat() to
cannam@49:       //   do it without losing any data in case the source lists come from a newer version of the
cannam@49:       //   protocol. (Plus, it's easier to use anyhow.)
cannam@49: 
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       builder.getStructElement(index * ELEMENTS).copyContentFrom(reader._reader);
cannam@49:     }
cannam@49: 
cannam@49:     // There are no init(), set(), adopt(), or disown() methods for lists of structs because the
cannam@49:     // elements of the list are inlined and are initialized when the list is initialized.  This
cannam@49:     // means that init() would be redundant, and set() would risk data loss if the input struct
cannam@49:     // were from a newer version of the protocol.
cannam@49: 
cannam@49:     typedef _::IndexingIterator<Builder, typename T::Builder> Iterator;
cannam@49:     inline Iterator begin() { return Iterator(this, 0); }
cannam@49:     inline Iterator end() { return Iterator(this, size()); }
cannam@49: 
cannam@49:   private:
cannam@49:     _::ListBuilder builder;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct _::PointerHelpers;
cannam@49:     friend class Orphanage;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct ToDynamic_;
cannam@49:   };
cannam@49: 
cannam@49:   class Pipeline {};
cannam@49: 
cannam@49: private:
cannam@49:   inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
cannam@49:     return builder.initStructList(size * ELEMENTS, _::structSize<T>());
cannam@49:   }
cannam@49:   inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
cannam@49:     return builder.getStructList(_::structSize<T>(), defaultValue);
cannam@49:   }
cannam@49:   inline static _::ListReader getFromPointer(
cannam@49:       const _::PointerReader& reader, const word* defaultValue) {
cannam@49:     return reader.getList(ElementSize::INLINE_COMPOSITE, defaultValue);
cannam@49:   }
cannam@49: 
cannam@49:   template <typename U, Kind k>
cannam@49:   friend struct List;
cannam@49:   template <typename U, Kind K>
cannam@49:   friend struct _::PointerHelpers;
cannam@49: };
cannam@49: 
cannam@49: template <typename T>
cannam@49: struct List<List<T>, Kind::LIST> {
cannam@49:   // List of lists.
cannam@49: 
cannam@49:   List() = delete;
cannam@49: 
cannam@49:   class Reader {
cannam@49:   public:
cannam@49:     typedef List<List<T>> Reads;
cannam@49: 
cannam@49:     inline Reader(): reader(ElementSize::POINTER) {}
cannam@49:     inline explicit Reader(_::ListReader reader): reader(reader) {}
cannam@49: 
cannam@49:     inline uint size() const { return reader.size() / ELEMENTS; }
cannam@49:     inline typename List<T>::Reader operator[](uint index) const {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return typename List<T>::Reader(
cannam@49:           _::PointerHelpers<List<T>>::get(reader.getPointerElement(index * ELEMENTS)));
cannam@49:     }
cannam@49: 
cannam@49:     typedef _::IndexingIterator<const Reader, typename List<T>::Reader> Iterator;
cannam@49:     inline Iterator begin() const { return Iterator(this, 0); }
cannam@49:     inline Iterator end() const { return Iterator(this, size()); }
cannam@49: 
cannam@49:   private:
cannam@49:     _::ListReader reader;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct _::PointerHelpers;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct List;
cannam@49:     friend class Orphanage;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct ToDynamic_;
cannam@49:   };
cannam@49: 
cannam@49:   class Builder {
cannam@49:   public:
cannam@49:     typedef List<List<T>> Builds;
cannam@49: 
cannam@49:     inline Builder(): builder(ElementSize::POINTER) {}
cannam@49:     inline Builder(decltype(nullptr)) {}
cannam@49:     inline explicit Builder(_::ListBuilder builder): builder(builder) {}
cannam@49: 
cannam@49:     inline operator Reader() const { return Reader(builder.asReader()); }
cannam@49:     inline Reader asReader() const { return Reader(builder.asReader()); }
cannam@49: 
cannam@49:     inline uint size() const { return builder.size() / ELEMENTS; }
cannam@49:     inline typename List<T>::Builder operator[](uint index) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return typename List<T>::Builder(
cannam@49:           _::PointerHelpers<List<T>>::get(builder.getPointerElement(index * ELEMENTS)));
cannam@49:     }
cannam@49:     inline typename List<T>::Builder init(uint index, uint size) {
cannam@49:       KJ_IREQUIRE(index < this->size());
cannam@49:       return typename List<T>::Builder(
cannam@49:           _::PointerHelpers<List<T>>::init(builder.getPointerElement(index * ELEMENTS), size));
cannam@49:     }
cannam@49:     inline void set(uint index, typename List<T>::Reader value) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       builder.getPointerElement(index * ELEMENTS).setList(value.reader);
cannam@49:     }
cannam@49:     void set(uint index, std::initializer_list<ReaderFor<T>> value) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       auto l = init(index, value.size());
cannam@49:       uint i = 0;
cannam@49:       for (auto& element: value) {
cannam@49:         l.set(i++, element);
cannam@49:       }
cannam@49:     }
cannam@49:     inline void adopt(uint index, Orphan<T>&& value) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       builder.getPointerElement(index * ELEMENTS).adopt(kj::mv(value.builder));
cannam@49:     }
cannam@49:     inline Orphan<T> disown(uint index) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return Orphan<T>(builder.getPointerElement(index * ELEMENTS).disown());
cannam@49:     }
cannam@49: 
cannam@49:     typedef _::IndexingIterator<Builder, typename List<T>::Builder> Iterator;
cannam@49:     inline Iterator begin() { return Iterator(this, 0); }
cannam@49:     inline Iterator end() { return Iterator(this, size()); }
cannam@49: 
cannam@49:   private:
cannam@49:     _::ListBuilder builder;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct _::PointerHelpers;
cannam@49:     friend class Orphanage;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct ToDynamic_;
cannam@49:   };
cannam@49: 
cannam@49:   class Pipeline {};
cannam@49: 
cannam@49: private:
cannam@49:   inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
cannam@49:     return builder.initList(ElementSize::POINTER, size * ELEMENTS);
cannam@49:   }
cannam@49:   inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
cannam@49:     return builder.getList(ElementSize::POINTER, defaultValue);
cannam@49:   }
cannam@49:   inline static _::ListReader getFromPointer(
cannam@49:       const _::PointerReader& reader, const word* defaultValue) {
cannam@49:     return reader.getList(ElementSize::POINTER, defaultValue);
cannam@49:   }
cannam@49: 
cannam@49:   template <typename U, Kind k>
cannam@49:   friend struct List;
cannam@49:   template <typename U, Kind K>
cannam@49:   friend struct _::PointerHelpers;
cannam@49: };
cannam@49: 
cannam@49: template <typename T>
cannam@49: struct List<T, Kind::BLOB> {
cannam@49:   List() = delete;
cannam@49: 
cannam@49:   class Reader {
cannam@49:   public:
cannam@49:     typedef List<T> Reads;
cannam@49: 
cannam@49:     inline Reader(): reader(ElementSize::POINTER) {}
cannam@49:     inline explicit Reader(_::ListReader reader): reader(reader) {}
cannam@49: 
cannam@49:     inline uint size() const { return reader.size() / ELEMENTS; }
cannam@49:     inline typename T::Reader operator[](uint index) const {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return reader.getPointerElement(index * ELEMENTS).template getBlob<T>(nullptr, 0 * BYTES);
cannam@49:     }
cannam@49: 
cannam@49:     typedef _::IndexingIterator<const Reader, typename T::Reader> Iterator;
cannam@49:     inline Iterator begin() const { return Iterator(this, 0); }
cannam@49:     inline Iterator end() const { return Iterator(this, size()); }
cannam@49: 
cannam@49:   private:
cannam@49:     _::ListReader reader;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct _::PointerHelpers;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct List;
cannam@49:     friend class Orphanage;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct ToDynamic_;
cannam@49:   };
cannam@49: 
cannam@49:   class Builder {
cannam@49:   public:
cannam@49:     typedef List<T> Builds;
cannam@49: 
cannam@49:     inline Builder(): builder(ElementSize::POINTER) {}
cannam@49:     inline Builder(decltype(nullptr)) {}
cannam@49:     inline explicit Builder(_::ListBuilder builder): builder(builder) {}
cannam@49: 
cannam@49:     inline operator Reader() const { return Reader(builder.asReader()); }
cannam@49:     inline Reader asReader() const { return Reader(builder.asReader()); }
cannam@49: 
cannam@49:     inline uint size() const { return builder.size() / ELEMENTS; }
cannam@49:     inline typename T::Builder operator[](uint index) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return builder.getPointerElement(index * ELEMENTS).template getBlob<T>(nullptr, 0 * BYTES);
cannam@49:     }
cannam@49:     inline void set(uint index, typename T::Reader value) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       builder.getPointerElement(index * ELEMENTS).template setBlob<T>(value);
cannam@49:     }
cannam@49:     inline typename T::Builder init(uint index, uint size) {
cannam@49:       KJ_IREQUIRE(index < this->size());
cannam@49:       return builder.getPointerElement(index * ELEMENTS).template initBlob<T>(size * BYTES);
cannam@49:     }
cannam@49:     inline void adopt(uint index, Orphan<T>&& value) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       builder.getPointerElement(index * ELEMENTS).adopt(kj::mv(value.builder));
cannam@49:     }
cannam@49:     inline Orphan<T> disown(uint index) {
cannam@49:       KJ_IREQUIRE(index < size());
cannam@49:       return Orphan<T>(builder.getPointerElement(index * ELEMENTS).disown());
cannam@49:     }
cannam@49: 
cannam@49:     typedef _::IndexingIterator<Builder, typename T::Builder> Iterator;
cannam@49:     inline Iterator begin() { return Iterator(this, 0); }
cannam@49:     inline Iterator end() { return Iterator(this, size()); }
cannam@49: 
cannam@49:   private:
cannam@49:     _::ListBuilder builder;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct _::PointerHelpers;
cannam@49:     friend class Orphanage;
cannam@49:     template <typename U, Kind K>
cannam@49:     friend struct ToDynamic_;
cannam@49:   };
cannam@49: 
cannam@49:   class Pipeline {};
cannam@49: 
cannam@49: private:
cannam@49:   inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
cannam@49:     return builder.initList(ElementSize::POINTER, size * ELEMENTS);
cannam@49:   }
cannam@49:   inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
cannam@49:     return builder.getList(ElementSize::POINTER, defaultValue);
cannam@49:   }
cannam@49:   inline static _::ListReader getFromPointer(
cannam@49:       const _::PointerReader& reader, const word* defaultValue) {
cannam@49:     return reader.getList(ElementSize::POINTER, defaultValue);
cannam@49:   }
cannam@49: 
cannam@49:   template <typename U, Kind k>
cannam@49:   friend struct List;
cannam@49:   template <typename U, Kind K>
cannam@49:   friend struct _::PointerHelpers;
cannam@49: };
cannam@49: 
cannam@49: }  // namespace capnp
cannam@49: 
cannam@49: #ifdef KJ_STD_COMPAT
cannam@49: namespace std {
cannam@49: 
cannam@49: template <typename Container, typename Element>
cannam@49: struct iterator_traits<capnp::_::IndexingIterator<Container, Element>>
cannam@49:       : public std::iterator<std::random_access_iterator_tag, Element, int> {};
cannam@49: 
cannam@49: }  // namespace std
cannam@49: #endif  // KJ_STD_COMPAT
cannam@49: 
cannam@49: #endif  // CAPNP_LIST_H_