comparison win64-msvc/include/capnp/list.h @ 148:b4bfdf10c4b3

Update Win64 capnp builds to v0.6

     typedef List<T> Reads;
 
     inline Reader(): reader(_::elementSizeForType<T>()) {}
     inline explicit Reader(_::ListReader reader): reader(reader) {}
 
-    inline uint size() const { return reader.size() / ELEMENTS; }
+    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
     inline T operator[](uint index) const {
       KJ_IREQUIRE(index < size());
-      return reader.template getDataElement<T>(index * ELEMENTS);
+      return reader.template getDataElement<T>(bounded(index) * ELEMENTS);
     }
 
     typedef _::IndexingIterator<const Reader, T> Iterator;
     inline Iterator begin() const { return Iterator(this, 0); }
     inline Iterator end() const { return Iterator(this, size()); }

   class Builder {
   public:
     typedef List<T> Builds;
 
     inline Builder(): builder(_::elementSizeForType<T>()) {}
-    inline Builder(decltype(nullptr)) {}
+    inline Builder(decltype(nullptr)): Builder() {}
     inline explicit Builder(_::ListBuilder builder): builder(builder) {}
 
     inline operator Reader() const { return Reader(builder.asReader()); }
     inline Reader asReader() const { return Reader(builder.asReader()); }
 
-    inline uint size() const { return builder.size() / ELEMENTS; }
+    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
     inline T operator[](uint index) {
       KJ_IREQUIRE(index < size());
-      return builder.template getDataElement<T>(index * ELEMENTS);
+      return builder.template getDataElement<T>(bounded(index) * ELEMENTS);
     }
     inline void set(uint index, T value) {
       // Alas, it is not possible to make operator[] return a reference to which you can assign,
       // since the encoded representation does not necessarily match the compiler's representation
       // of the type.  We can't even return a clever class that implements operator T() and
       // operator=() because it will lead to surprising behavior when using type inference (e.g.
       // calling a template function with inferred argument types, or using "auto" or "decltype").
 
-      builder.template setDataElement<T>(index * ELEMENTS, value);
+      builder.template setDataElement<T>(bounded(index) * ELEMENTS, value);
     }
 
     typedef _::IndexingIterator<Builder, T> Iterator;
     inline Iterator begin() { return Iterator(this, 0); }
     inline Iterator end() { return Iterator(this, size()); }

 
   class Pipeline {};
 
 private:
   inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
-    return builder.initList(_::elementSizeForType<T>(), size * ELEMENTS);
+    return builder.initList(_::elementSizeForType<T>(), bounded(size) * ELEMENTS);
   }
   inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
     return builder.getList(_::elementSizeForType<T>(), defaultValue);
   }
   inline static _::ListReader getFromPointer(

     typedef List<T> Reads;
 
     inline Reader(): reader(ElementSize::INLINE_COMPOSITE) {}
     inline explicit Reader(_::ListReader reader): reader(reader) {}
 
-    inline uint size() const { return reader.size() / ELEMENTS; }
+    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
     inline typename T::Reader operator[](uint index) const {
       KJ_IREQUIRE(index < size());
-      return typename T::Reader(reader.getStructElement(index * ELEMENTS));
+      return typename T::Reader(reader.getStructElement(bounded(index) * ELEMENTS));
     }
 
     typedef _::IndexingIterator<const Reader, typename T::Reader> Iterator;
     inline Iterator begin() const { return Iterator(this, 0); }
     inline Iterator end() const { return Iterator(this, size()); }

   class Builder {
   public:
     typedef List<T> Builds;
 
     inline Builder(): builder(ElementSize::INLINE_COMPOSITE) {}
-    inline Builder(decltype(nullptr)) {}
+    inline Builder(decltype(nullptr)): Builder() {}
     inline explicit Builder(_::ListBuilder builder): builder(builder) {}
 
     inline operator Reader() const { return Reader(builder.asReader()); }
     inline Reader asReader() const { return Reader(builder.asReader()); }
 
-    inline uint size() const { return builder.size() / ELEMENTS; }
+    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
     inline typename T::Builder operator[](uint index) {
       KJ_IREQUIRE(index < size());
-      return typename T::Builder(builder.getStructElement(index * ELEMENTS));
+      return typename T::Builder(builder.getStructElement(bounded(index) * ELEMENTS));
     }
 
     inline void adoptWithCaveats(uint index, Orphan<T>&& orphan) {
       // Mostly behaves like you'd expect `adopt` to behave, but with two caveats originating from
       // the fact that structs in a struct list are allocated inline rather than by pointer:

       KJ_IREQUIRE(index < size());
 
       // We pass a zero-valued StructSize to asStruct() because we do not want the struct to be
       // expanded under any circumstances.  We're just going to throw it away anyway, and
       // transferContentFrom() already carefully compares the struct sizes before transferring.
-      builder.getStructElement(index * ELEMENTS).transferContentFrom(
-          orphan.builder.asStruct(_::StructSize(0 * WORDS, 0 * POINTERS)));
+      builder.getStructElement(bounded(index) * ELEMENTS).transferContentFrom(
+          orphan.builder.asStruct(_::StructSize(ZERO * WORDS, ZERO * POINTERS)));
     }
     inline void setWithCaveats(uint index, const typename T::Reader& reader) {
       // Mostly behaves like you'd expect `set` to behave, but with a caveat originating from
       // the fact that structs in a struct list are allocated inline rather than by pointer:
       // If the source struct is larger than the target struct -- say, because the source was built

       // Note: If you are trying to concatenate some lists, use Orphanage::newOrphanConcat() to
       //   do it without losing any data in case the source lists come from a newer version of the
       //   protocol. (Plus, it's easier to use anyhow.)
 
       KJ_IREQUIRE(index < size());
-      builder.getStructElement(index * ELEMENTS).copyContentFrom(reader._reader);
+      builder.getStructElement(bounded(index) * ELEMENTS).copyContentFrom(reader._reader);
     }
 
     // There are no init(), set(), adopt(), or disown() methods for lists of structs because the
     // elements of the list are inlined and are initialized when the list is initialized.  This
     // means that init() would be redundant, and set() would risk data loss if the input struct

 
   class Pipeline {};
 
 private:
   inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
-    return builder.initStructList(size * ELEMENTS, _::structSize<T>());
+    return builder.initStructList(bounded(size) * ELEMENTS, _::structSize<T>());
   }
   inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
     return builder.getStructList(_::structSize<T>(), defaultValue);
   }
   inline static _::ListReader getFromPointer(

     typedef List<List<T>> Reads;
 
     inline Reader(): reader(ElementSize::POINTER) {}
     inline explicit Reader(_::ListReader reader): reader(reader) {}
 
-    inline uint size() const { return reader.size() / ELEMENTS; }
+    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
     inline typename List<T>::Reader operator[](uint index) const {
       KJ_IREQUIRE(index < size());
-      return typename List<T>::Reader(
-          _::PointerHelpers<List<T>>::get(reader.getPointerElement(index * ELEMENTS)));
+      return typename List<T>::Reader(_::PointerHelpers<List<T>>::get(
+          reader.getPointerElement(bounded(index) * ELEMENTS)));
     }
 
     typedef _::IndexingIterator<const Reader, typename List<T>::Reader> Iterator;
     inline Iterator begin() const { return Iterator(this, 0); }
     inline Iterator end() const { return Iterator(this, size()); }

   class Builder {
   public:
     typedef List<List<T>> Builds;
 
     inline Builder(): builder(ElementSize::POINTER) {}
-    inline Builder(decltype(nullptr)) {}
+    inline Builder(decltype(nullptr)): Builder() {}
     inline explicit Builder(_::ListBuilder builder): builder(builder) {}
 
     inline operator Reader() const { return Reader(builder.asReader()); }
     inline Reader asReader() const { return Reader(builder.asReader()); }
 
-    inline uint size() const { return builder.size() / ELEMENTS; }
+    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
     inline typename List<T>::Builder operator[](uint index) {
       KJ_IREQUIRE(index < size());
-      return typename List<T>::Builder(
-          _::PointerHelpers<List<T>>::get(builder.getPointerElement(index * ELEMENTS)));
+      return typename List<T>::Builder(_::PointerHelpers<List<T>>::get(
+          builder.getPointerElement(bounded(index) * ELEMENTS)));
     }
     inline typename List<T>::Builder init(uint index, uint size) {
       KJ_IREQUIRE(index < this->size());
-      return typename List<T>::Builder(
-          _::PointerHelpers<List<T>>::init(builder.getPointerElement(index * ELEMENTS), size));
+      return typename List<T>::Builder(_::PointerHelpers<List<T>>::init(
+          builder.getPointerElement(bounded(index) * ELEMENTS), size));
     }
     inline void set(uint index, typename List<T>::Reader value) {
       KJ_IREQUIRE(index < size());
-      builder.getPointerElement(index * ELEMENTS).setList(value.reader);
+      builder.getPointerElement(bounded(index) * ELEMENTS).setList(value.reader);
     }
     void set(uint index, std::initializer_list<ReaderFor<T>> value) {
       KJ_IREQUIRE(index < size());
       auto l = init(index, value.size());
       uint i = 0;

         l.set(i++, element);
       }
     }
     inline void adopt(uint index, Orphan<T>&& value) {
       KJ_IREQUIRE(index < size());
-      builder.getPointerElement(index * ELEMENTS).adopt(kj::mv(value.builder));
+      builder.getPointerElement(bounded(index) * ELEMENTS).adopt(kj::mv(value.builder));
     }
     inline Orphan<T> disown(uint index) {
       KJ_IREQUIRE(index < size());
-      return Orphan<T>(builder.getPointerElement(index * ELEMENTS).disown());
+      return Orphan<T>(builder.getPointerElement(bounded(index) * ELEMENTS).disown());
     }
 
     typedef _::IndexingIterator<Builder, typename List<T>::Builder> Iterator;
     inline Iterator begin() { return Iterator(this, 0); }
     inline Iterator end() { return Iterator(this, size()); }

 
   class Pipeline {};
 
 private:
   inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
-    return builder.initList(ElementSize::POINTER, size * ELEMENTS);
+    return builder.initList(ElementSize::POINTER, bounded(size) * ELEMENTS);
   }
   inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
     return builder.getList(ElementSize::POINTER, defaultValue);
   }
   inline static _::ListReader getFromPointer(

     typedef List<T> Reads;
 
     inline Reader(): reader(ElementSize::POINTER) {}
     inline explicit Reader(_::ListReader reader): reader(reader) {}
 
-    inline uint size() const { return reader.size() / ELEMENTS; }
+    inline uint size() const { return unbound(reader.size() / ELEMENTS); }
     inline typename T::Reader operator[](uint index) const {
       KJ_IREQUIRE(index < size());
-      return reader.getPointerElement(index * ELEMENTS).template getBlob<T>(nullptr, 0 * BYTES);
+      return reader.getPointerElement(bounded(index) * ELEMENTS)
+          .template getBlob<T>(nullptr, ZERO * BYTES);
     }
 
     typedef _::IndexingIterator<const Reader, typename T::Reader> Iterator;
     inline Iterator begin() const { return Iterator(this, 0); }
     inline Iterator end() const { return Iterator(this, size()); }

   class Builder {
   public:
     typedef List<T> Builds;
 
     inline Builder(): builder(ElementSize::POINTER) {}
-    inline Builder(decltype(nullptr)) {}
+    inline Builder(decltype(nullptr)): Builder() {}
     inline explicit Builder(_::ListBuilder builder): builder(builder) {}
 
     inline operator Reader() const { return Reader(builder.asReader()); }
     inline Reader asReader() const { return Reader(builder.asReader()); }
 
-    inline uint size() const { return builder.size() / ELEMENTS; }
+    inline uint size() const { return unbound(builder.size() / ELEMENTS); }
     inline typename T::Builder operator[](uint index) {
       KJ_IREQUIRE(index < size());
-      return builder.getPointerElement(index * ELEMENTS).template getBlob<T>(nullptr, 0 * BYTES);
+      return builder.getPointerElement(bounded(index) * ELEMENTS)
+          .template getBlob<T>(nullptr, ZERO * BYTES);
     }
     inline void set(uint index, typename T::Reader value) {
       KJ_IREQUIRE(index < size());
-      builder.getPointerElement(index * ELEMENTS).template setBlob<T>(value);
+      builder.getPointerElement(bounded(index) * ELEMENTS).template setBlob<T>(value);
     }
     inline typename T::Builder init(uint index, uint size) {
       KJ_IREQUIRE(index < this->size());
-      return builder.getPointerElement(index * ELEMENTS).template initBlob<T>(size * BYTES);
+      return builder.getPointerElement(bounded(index) * ELEMENTS)
+          .template initBlob<T>(bounded(size) * BYTES);
     }
     inline void adopt(uint index, Orphan<T>&& value) {
       KJ_IREQUIRE(index < size());
-      builder.getPointerElement(index * ELEMENTS).adopt(kj::mv(value.builder));
+      builder.getPointerElement(bounded(index) * ELEMENTS).adopt(kj::mv(value.builder));
     }
     inline Orphan<T> disown(uint index) {
       KJ_IREQUIRE(index < size());
-      return Orphan<T>(builder.getPointerElement(index * ELEMENTS).disown());
+      return Orphan<T>(builder.getPointerElement(bounded(index) * ELEMENTS).disown());
     }
 
     typedef _::IndexingIterator<Builder, typename T::Builder> Iterator;
     inline Iterator begin() { return Iterator(this, 0); }
     inline Iterator end() { return Iterator(this, size()); }

 
   class Pipeline {};
 
 private:
   inline static _::ListBuilder initPointer(_::PointerBuilder builder, uint size) {
-    return builder.initList(ElementSize::POINTER, size * ELEMENTS);
+    return builder.initList(ElementSize::POINTER, bounded(size) * ELEMENTS);
   }
   inline static _::ListBuilder getFromPointer(_::PointerBuilder builder, const word* defaultValue) {
     return builder.getList(ElementSize::POINTER, defaultValue);
   }
   inline static _::ListReader getFromPointer(