Rename the 'Message' interfaces to Arena and make them internal. Make a new,…

Rename the 'Message' interfaces to Arena and make them internal.  Make a new, intuitive 'Message' interface for creating / reading messages.

c++/src/capnproto/arena.c++

+// Copyright (c) 2013, Kenton Varda <temporal@gmail.com>
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "arena.h"
+#include "message.h"
+#include <vector>
+#include <string.h>
+#include <iostream>
+
+namespace capnproto {
+namespace internal {
+
+Arena::~Arena() {}
+
+// =======================================================================================
+
+ReaderArena::ReaderArena(
+    ArrayPtr<const ArrayPtr<const word>> segments,
+    ErrorReporter* errorReporter,
+    WordCount64 readLimit)
+    : segments(segments),
+      errorReporter(errorReporter),
+      readLimiter(readLimit) {
+  segmentReaders.reserve(segments.size());
+  uint i = 0;
+  for (auto segment: segments) {
+    segmentReaders.emplace_back(new SegmentReader(this, SegmentId(i++), segment, &readLimiter));
+  }
+}
+
+ReaderArena::~ReaderArena() {}
+
+ArrayPtr<const ArrayPtr<const word>> ReaderArena::getSegmentsForOutput() {
+  return segments;
+}
+
+SegmentReader* ReaderArena::tryGetSegment(SegmentId id) {
+  if (id.value >= segments.size()) {
+    return nullptr;
+  } else {
+    return segmentReaders[id.value].get();
+  }
+}
+
+void ReaderArena::reportInvalidData(const char* description) {
+  errorReporter->reportError(description);
+}
+
+void ReaderArena::reportReadLimitReached() {
+  errorReporter->reportError("Exceeded read limit.");
+}
+
+// =======================================================================================
+
+BuilderArena::BuilderArena(Allocator* allocator): allocator(allocator) {}
+BuilderArena::~BuilderArena() {
+  // TODO:  This is wrong because we aren't taking into account how much of each segment is actually
+  //   allocated.
+  uint i = 0;
+  for (ArrayPtr<word> ptr: memory) {
+    // The memory array contains Array<const word> only to ease implementation of getSegmentsForOutput().
+    // We actually own this space and can de-constify it.
+    allocator->free(SegmentId(i++), ptr);
+  }
+}
+
+SegmentBuilder* BuilderArena::getSegment(SegmentId id) {
+  return segments[id.value].get();
+}
+
+SegmentBuilder* BuilderArena::getSegmentWithAvailable(WordCount minimumAvailable) {
+  if (segments.empty() || segments.back()->available() < minimumAvailable) {
+    ArrayPtr<word> array = allocator->allocate(
+        SegmentId(segments.size()), minimumAvailable / WORDS);
+    memory.push_back(array);
+    segments.push_back(std::unique_ptr<SegmentBuilder>(new SegmentBuilder(
+        this, SegmentId(segments.size()), array, &dummyLimiter)));
+  }
+  return segments.back().get();
+}
+
+ArrayPtr<const ArrayPtr<const word>> BuilderArena::getSegmentsForOutput() {
+  segmentsForOutput.resize(segments.size());
+  for (uint i = 0; i < segments.size(); i++) {
+    segmentsForOutput[i] = segments[i]->currentlyAllocated();
+  }
+
+  return arrayPtr(&*segmentsForOutput.begin(), segmentsForOutput.size());
+}
+
+SegmentReader* BuilderArena::tryGetSegment(SegmentId id) {
+  if (id.value >= segments.size()) {
+    return nullptr;
+  } else {
+    return segments[id.value].get();
+  }
+}
+
+void BuilderArena::reportInvalidData(const char* description) {
+  // TODO:  Better error reporting.
+  std::cerr << "BuilderArena: Parse error: " << description << std::endl;
+}
+
+void BuilderArena::reportReadLimitReached() {
+  // TODO:  Better error reporting.
+  std::cerr << "BuilderArena: Exceeded read limit." << std::endl;
+}
+
+}  // namespace internal
+}  // namespace capnproto

c++/src/capnproto/encoding-test.c++

@@ -227,56 +227,86 @@ void checkMessage(Reader reader) {
 }
 
 TEST(Encoding, AllTypes) {
-  auto root = newMallocMessageRoot<TestAllTypes>();
+  Message<TestAllTypes>::Builder builder;
 
-  initMessage(root.builder);
-  checkMessage(root.builder);
-  checkMessage(root.builder.asReader());
+  initMessage(builder.initRoot());
+  checkMessage(builder.getRoot());
+  checkMessage(builder.getRoot().asReader());
+
+  Message<TestAllTypes>::Reader reader(
+      builder.getSegmentsForOutput(), 64, 1 << 30, ThrowingErrorReporter::getDefaultInstance());
+
+  checkMessage(reader.getRoot());
+
+  ASSERT_EQ(1u, builder.getSegmentsForOutput().size());
+
+  checkMessage(Message<TestAllTypes>::readTrusted(builder.getSegmentsForOutput()[0].begin()));
 }
 
 TEST(Encoding, AllTypesMultiSegment) {
-  auto root = newMallocMessageRoot<TestAllTypes>(0 * WORDS);
+  MallocAllocator allocator(0);
+  Message<TestAllTypes>::Builder builder(&allocator);
 
-  initMessage(root.builder);
-  checkMessage(root.builder);
-  checkMessage(root.builder.asReader());
+  initMessage(builder.initRoot());
+  checkMessage(builder.getRoot());
+  checkMessage(builder.getRoot().asReader());
+
+  Message<TestAllTypes>::Reader reader(
+      builder.getSegmentsForOutput(), 64, 1 << 30, ThrowingErrorReporter::getDefaultInstance());
+
+  checkMessage(reader.getRoot());
 }
 
 TEST(Encoding, Defaults) {
-  auto root = newMallocMessageRoot<TestDefaults>();
+  AlignedData<1> nullRoot = {{0, 0, 0, 0, 0, 0, 0, 0}};
+  ArrayPtr<const word> segments[1] = {arrayPtr(nullRoot.words, 1)};
+  Message<TestDefaults>::Reader reader(arrayPtr(segments, 1), 64, 1 << 30,
+      ThrowingErrorReporter::getDefaultInstance());
 
-  checkMessage(root.builder.asReader());
+  checkMessage(reader.getRoot());
+  checkMessage(Message<TestDefaults>::readTrusted(nullRoot.words));
 }
 
 TEST(Encoding, DefaultInitialization) {
-  auto root = newMallocMessageRoot<TestDefaults>();
+  Message<TestDefaults>::Builder builder;
+
+  checkMessage(builder.getRoot());  // first pass initializes to defaults
+  checkMessage(builder.getRoot().asReader());
 
-  checkMessage(root.builder);
-  checkMessage(root.builder.asReader());
+  checkMessage(builder.getRoot());  // second pass just reads the initialized structure
+  checkMessage(builder.getRoot().asReader());
+
+  Message<TestDefaults>::Reader reader(
+      builder.getSegmentsForOutput(), 64, 1 << 30, ThrowingErrorReporter::getDefaultInstance());
+
+  checkMessage(reader.getRoot());
 }
 
 TEST(Encoding, DefaultInitializationMultiSegment) {
-  auto root = newMallocMessageRoot<TestDefaults>(0 * WORDS);
+  MallocAllocator allocator(0);
+  Message<TestDefaults>::Builder builder(&allocator);
+
+  checkMessage(builder.getRoot());  // first pass initializes to defaults
+  checkMessage(builder.getRoot().asReader());
 
-  checkMessage(root.builder);
-  checkMessage(root.builder.asReader());
+  checkMessage(builder.getRoot());  // second pass just reads the initialized structure
+  checkMessage(builder.getRoot().asReader());
+
+  Message<TestDefaults>::Reader reader(
+      builder.getSegmentsForOutput(), 64, 1 << 30, ThrowingErrorReporter::getDefaultInstance());
+
+  checkMessage(reader.getRoot());
 }
 
-TEST(Encoding, DefaultsNotOnWire) {
+TEST(Encoding, DefaultsFromEmptyMessage) {
   AlignedData<1> emptyMessage = {{4, 0, 0, 0, 0, 0, 0, 0}};
 
-  std::unique_ptr<MessageBuilder> message = newMallocMessage(512 * WORDS);
-  SegmentBuilder* segment = message->getSegmentWithAvailable(1 * WORDS);
-  word* rootLocation = segment->allocate(1 * WORDS);
-  memcpy(rootLocation, emptyMessage.words, sizeof(word));
-
-  TestDefaults::Reader reader(StructReader::readRoot(
-      emptyMessage.words, TestDefaults::DEFAULT.words, segment, 64));
-  checkMessage(reader);
+  ArrayPtr<const word> segments[1] = {arrayPtr(emptyMessage.words, 1)};
+  Message<TestDefaults>::Reader reader(arrayPtr(segments, 1), 64, 1 << 30,
+      ThrowingErrorReporter::getDefaultInstance());
 
-  TestDefaults::Reader reader2(StructReader::readRootTrusted(
-      emptyMessage.words, TestDefaults::DEFAULT.words));
-  checkMessage(reader2);
+  checkMessage(reader.getRoot());
+  checkMessage(Message<TestDefaults>::readTrusted(emptyMessage.words));
 }
 
 }  // namespace

c++/src/capnproto/macros.c++

@@ -22,10 +22,9 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "macros.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <exception>
+#include <string>
+#include <unistd.h>
 
 namespace capnproto {
 namespace internal {
@@ -35,39 +34,33 @@ class Exception: public std::exception {
 
 public:
   Exception(const char* file, int line, const char* expectation, const char* message);
-  virtual ~Exception() noexcept;
+  ~Exception() noexcept;
 
-  const char* getFile() { return file; }
-  int getLine() { return line; }
-  const char* getExpectation() { return expectation; }
-  const char* getMessage() { return message; }
-
-  virtual const char* what();
+  const char* what() const noexcept override;
 
 private:
-  const char* file;
-  int line;
-  const char* expectation;
-  const char* message;
-  char* whatBuffer;
+  std::string description;
 };
 
 Exception::Exception(
-    const char* file, int line, const char* expectation, const char* message)
-    : file(file), line(line), expectation(expectation), message(message), whatBuffer(nullptr) {
-  fprintf(stderr, "Captain Proto debug assertion failed:\n  %s:%d: %s\n  %s",
-          file, line, expectation, message);
-}
+    const char* file, int line, const char* expectation, const char* message) {
+  description = "Captain Proto debug assertion failed:\n  ";
+  description += file;
+  description += ':';
+  description += line;
+  description += ": ";
+  description += expectation;
+  description += "\n  ";
+  description += message;
+  description += "\n";
 
-Exception::~Exception() noexcept {
-  delete [] whatBuffer;
+  write(STDERR_FILENO, description.data(), description.size());
 }
 
-const char* Exception::what() {
-  whatBuffer = new char[strlen(file) + strlen(expectation) + strlen(message) + 256];
-  sprintf(whatBuffer, "Captain Proto debug assertion failed:\n  %s:%d: %s\n  %s",
-          file, line, expectation, message);
-  return whatBuffer;
+Exception::~Exception() noexcept {}
+
+const char* Exception::what() const noexcept {
+  return description.c_str();
 }
 
 void assertionFailure(const char* file, int line, const char* expectation, const char* message) {

c++/src/capnproto/message-internal.h

+// Copyright (c) 2013, Kenton Varda <temporal@gmail.com>
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This header contains internal interfaces relied upon by message.h and implemented in message.c++.
+// These declarations should be thought of as being part of message.h, but I moved them here to make
+// message.h more readable.  The problem is that the interface people really care about in
+// message.h -- namely, Message -- has to be declared after internal::Message.  Having an internal
+// interface appear in the middle of the header ahead of the public interface was distracting and
+// confusing.
+
+#ifndef CAPNPROTO_MESSAGE_INTERNAL_H_
+#define CAPNPROTO_MESSAGE_INTERNAL_H_
+
+#include <cstddef>
+#include <memory>
+#include "type-safety.h"
+#include "wire-format.h"
+
+namespace capnproto {
+  class Allocator;
+  class ErrorReporter;
+}
+
+namespace capnproto {
+namespace internal {
+// TODO:  Move to message-internal.h so that this header looks nicer?
+
+class Arena;
+class BuilderArena;
+
+struct MessageImpl {
+  // Underlying implementation of capnproto::Message.  All the parts that don't need to be templated
+  // are implemented by this class, so that they can be shared and non-inline.
+
+  MessageImpl() = delete;
+
+  class Reader {
+  public:
+    Reader(ArrayPtr<const ArrayPtr<const word>> segments,
+           uint recursionLimit, uint64_t readLimit, ErrorReporter* errorReporter);
+    Reader(Reader&& other) = default;
+    CAPNPROTO_DISALLOW_COPY(Reader);
+    ~Reader();
+
+    StructReader getRoot(const word* defaultValue);
+
+  private:
+    std::unique_ptr<Arena> arena;
+    uint recursionLimit;
+  };
+
+  class Builder {
+  public:
+    Builder();
+    Builder(Allocator* allocator);
+
+    Builder(Builder&& other) = default;
+    CAPNPROTO_DISALLOW_COPY(Builder);
+    ~Builder();
+
+    StructBuilder initRoot(const word* defaultValue);
+    StructBuilder getRoot(const word* defaultValue);
+
+    ArrayPtr<const ArrayPtr<const word>> getSegmentsForOutput();
+
+  private:
+    std::unique_ptr<BuilderArena> arena;
+    SegmentBuilder* rootSegment;
+
+    static SegmentBuilder* allocateRoot(BuilderArena* arena);
+  };
+};
+
+}  // namespace internal
+}  // namespace capnproto
+
+#endif  // CAPNPROTO_MESSAGE_INTERNAL_H_

c++/src/capnproto/message.c++

@@ -22,75 +22,131 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "message.h"
-#include <vector>
-#include <string.h>
-#include <iostream>
-#include <stdlib.h>
+#include "arena.h"
+#include "stdlib.h"
+#include <exception>
+#include <string>
+#include <unistd.h>
 
 namespace capnproto {
 
-MessageReader::~MessageReader() {}
-MessageBuilder::~MessageBuilder() {}
+Allocator::~Allocator() {}
+ErrorReporter::~ErrorReporter() {}
 
-class MallocMessage: public MessageBuilder {
+MallocAllocator::MallocAllocator(uint preferredSegmentSizeWords)
+    : preferredSegmentSizeWords(preferredSegmentSizeWords) {}
+MallocAllocator::~MallocAllocator() {}
+
+MallocAllocator* MallocAllocator::getDefaultInstance() {
+  static MallocAllocator defaultInstance(1024);
+  return &defaultInstance;
+}
+
+ArrayPtr<word> MallocAllocator::allocate(SegmentId id, uint minimumSize) {
+  uint size = std::max(minimumSize, preferredSegmentSizeWords);
+  return arrayPtr(reinterpret_cast<word*>(calloc(size, sizeof(word))), size);
+}
+void MallocAllocator::free(SegmentId id, ArrayPtr<word> ptr) {
+  ::free(ptr.begin());
+}
+
+StderrErrorReporter::~StderrErrorReporter() {}
+
+StderrErrorReporter* StderrErrorReporter::getDefaultInstance() {
+  static StderrErrorReporter defaultInstance;
+  return &defaultInstance;
+}
+
+void StderrErrorReporter::reportError(const char* description) {
+  std::string message("ERROR: Cap'n Proto parse error: ");
+  message += description;
+  message += '\n';
+  write(STDERR_FILENO, message.data(), message.size());
+}
+
+class ParseException: public std::exception {
 public:
-  MallocMessage(WordCount preferredSegmentSize);
-  ~MallocMessage();
+  ParseException(const char* description);
+  ~ParseException() noexcept;
 
-  SegmentReader* tryGetSegment(SegmentId id);
-  void reportInvalidData(const char* description);
-  void reportReadLimitReached();
-  SegmentBuilder* getSegment(SegmentId id);
-  SegmentBuilder* getSegmentWithAvailable(WordCount minimumAvailable);
+  const char* what() const noexcept override;
 
 private:
-  WordCount preferredSegmentSize;
-  std::vector<std::unique_ptr<SegmentBuilder>> segments;
-  std::vector<word*> memory;
+  std::string description;
 };
 
-MallocMessage::MallocMessage(WordCount preferredSegmentSize)
-    : preferredSegmentSize(preferredSegmentSize) {}
-MallocMessage::~MallocMessage() {
-  for (word* ptr: memory) {
-    free(ptr);
-  }
+ParseException::ParseException(const char* description)
+    : description(description) {}
+
+ParseException::~ParseException() noexcept {}
+
+const char* ParseException::what() const noexcept {
+  return description.c_str();
+}
+
+ThrowingErrorReporter::~ThrowingErrorReporter() {}
+
+ThrowingErrorReporter* ThrowingErrorReporter::getDefaultInstance() {
+  static ThrowingErrorReporter defaultInstance;
+  return &defaultInstance;
+}
+
+void ThrowingErrorReporter::reportError(const char* description) {
+  throw ParseException(description);
 }
 
-SegmentReader* MallocMessage::tryGetSegment(SegmentId id) {
-  if (id.value >= segments.size()) {
-    return nullptr;
+// =======================================================================================
+
+namespace internal {
+
+MessageImpl::Reader::Reader(ArrayPtr<const ArrayPtr<const word>> segments,
+       uint recursionLimit, uint64_t readLimit, ErrorReporter* errorReporter)
+    : arena(new ReaderArena(segments, errorReporter, readLimit * WORDS)),
+      recursionLimit(recursionLimit) {}
+MessageImpl::Reader::~Reader() {}
+
+StructReader MessageImpl::Reader::getRoot(const word* defaultValue) {
+  SegmentReader* segment = arena->tryGetSegment(SegmentId(0));
+  if (segment == nullptr ||
+      !segment->containsInterval(segment->getStartPtr(), segment->getStartPtr() + 1)) {
+    segment->getArena()->reportInvalidData("Message did not contain a root pointer.");
+    return StructReader::readRootTrusted(defaultValue, defaultValue);
   } else {
-    return segments[id.value].get();
+    return StructReader::readRoot(segment->getStartPtr(), defaultValue, segment, recursionLimit);
   }
 }
 
-void MallocMessage::reportInvalidData(const char* description) {
-  // TODO:  Better error reporting.
-  std::cerr << "MallocMessage: Parse error: " << description << std::endl;
-}
+MessageImpl::Builder::Builder()
+    : arena(new BuilderArena(MallocAllocator::getDefaultInstance())),
+      rootSegment(allocateRoot(arena.get())) {}
+MessageImpl::Builder::Builder(Allocator* allocator)
+    : arena(new BuilderArena(allocator)),
+      rootSegment(allocateRoot(arena.get())) {}
+MessageImpl::Builder::~Builder() {}
 
-void MallocMessage::reportReadLimitReached() {
-  // TODO:  Better error reporting.
-  std::cerr << "MallocMessage: Exceeded read limit." << std::endl;
+StructBuilder MessageImpl::Builder::initRoot(const word* defaultValue) {
+  return StructBuilder::initRoot(
+      rootSegment, rootSegment->getPtrUnchecked(0 * WORDS), defaultValue);
 }
 
-SegmentBuilder* MallocMessage::getSegment(SegmentId id) {
-  return segments[id.value].get();
+StructBuilder MessageImpl::Builder::getRoot(const word* defaultValue) {
+  return StructBuilder::getRoot(rootSegment, rootSegment->getPtrUnchecked(0 * WORDS), defaultValue);
 }
 
-SegmentBuilder* MallocMessage::getSegmentWithAvailable(WordCount minimumAvailable) {
-  if (segments.empty() || segments.back()->available() < minimumAvailable) {
-    WordCount newSize = std::max(minimumAvailable, preferredSegmentSize);
-    memory.push_back(reinterpret_cast<word*>(calloc(newSize / WORDS, sizeof(word))));
-    segments.push_back(std::unique_ptr<SegmentBuilder>(new SegmentBuilder(
-        this, SegmentId(segments.size()), memory.back(), newSize)));
-  }
-  return segments.back().get();
+ArrayPtr<const ArrayPtr<const word>> MessageImpl::Builder::getSegmentsForOutput() {
+  return arena->getSegmentsForOutput();
 }
 
-std::unique_ptr<MessageBuilder> newMallocMessage(WordCount preferredSegmentSize) {
-  return std::unique_ptr<MessageBuilder>(new MallocMessage(preferredSegmentSize));
+SegmentBuilder* MessageImpl::Builder::allocateRoot(BuilderArena* arena) {
+  WordCount refSize = 1 * REFERENCES * WORDS_PER_REFERENCE;
+  SegmentBuilder* segment = arena->getSegmentWithAvailable(refSize);
+  CAPNPROTO_ASSERT(segment->getSegmentId() == SegmentId(0),
+      "First allocated word of new arena was not in segment ID 0.");
+  word* location = segment->allocate(refSize);
+  CAPNPROTO_ASSERT(location == segment->getPtrUnchecked(0 * WORDS),
+      "First allocated word of new arena was not the first word in its segment.");
+  return segment;
 }
 
+}  // namespace internal
 }  // namespace capnproto

c++/src/capnproto/type-safety.h

@@ -29,6 +29,7 @@
 #define CAPNPROTO_TYPE_SAFETY_H_
 
 #include "macros.h"
+#include <cstddef>
 
 namespace capnproto {
 
@@ -50,6 +51,55 @@ struct NoInfer {
   typedef T Type;
 };
 
+// =======================================================================================
+// ArrayPtr
+
+template <typename T>
+class ArrayPtr {
+  // A pointer to an array.  Includes a size.  Like any pointer, it doesn't own the target data,
+  // and passing by value only copies the pointer, not the target.
+
+public:
+  inline ArrayPtr(): ptr(nullptr), size_(0) {}
+  inline ArrayPtr(std::nullptr_t): ptr(nullptr), size_(0) {}
+  inline ArrayPtr(T* ptr, std::size_t size): ptr(ptr), size_(size) {}
+  inline ArrayPtr(T* begin, T* end): ptr(begin), size_(end - begin) {}
+
+  inline operator ArrayPtr<const T>() {
+    return ArrayPtr<const T>(ptr, size_);
+  }
+
+  inline std::size_t size() const { return size_; }
+  inline T& operator[](std::size_t index) const {
+    CAPNPROTO_DEBUG_ASSERT(index < size_, "Out-of-bounds ArrayPtr access.");
+    return ptr[index];
+  }
+
+  inline T* begin() const { return ptr; }
+  inline T* end() const { return ptr + size_; }
+
+  inline ArrayPtr slice(size_t start, size_t end) {
+    CAPNPROTO_DEBUG_ASSERT(start <= end && end <= size_, "Out-of-bounds ArrayPtr::slice().");
+    return ArrayPtr(ptr + start, end - start);
+  }
+
+private:
+  T* ptr;
+  std::size_t size_;
+};
+
+template <typename T>
+inline ArrayPtr<T> arrayPtr(T* ptr, size_t size) {
+  // Use this function to construct ArrayPtrs without writing out the type name.
+  return ArrayPtr<T>(ptr, size);
+}
+
+template <typename T>
+inline ArrayPtr<T> arrayPtr(T* begin, T* end) {
+  // Use this function to construct ArrayPtrs without writing out the type name.
+  return ArrayPtr<T>(begin, end);
+}
+
 // =======================================================================================
 // IDs
 

c++/src/capnproto/wire-format-test.c++

@@ -24,6 +24,7 @@
 #include "wire-format.h"
 #include "descriptor.h"
 #include "message.h"
+#include "arena.h"
 #include <gtest/gtest.h>
 
 namespace capnproto {
@@ -263,8 +264,8 @@ static void checkStruct(StructReader reader) {
 }
 
 TEST(WireFormat, StructRoundTrip_OneSegment) {
-  std::unique_ptr<MessageBuilder> message = newMallocMessage(512 * WORDS);
-  SegmentBuilder* segment = message->getSegmentWithAvailable(1 * WORDS);
+  BuilderArena arena(MallocAllocator::getDefaultInstance());
+  SegmentBuilder* segment = arena.getSegmentWithAvailable(1 * WORDS);
   word* rootLocation = segment->allocate(1 * WORDS);
 
   StructBuilder builder = StructBuilder::initRoot(segment, rootLocation, STRUCT_DEFAULT.words);
@@ -286,7 +287,9 @@ TEST(WireFormat, StructRoundTrip_OneSegment) {
   //         6 sub-lists (4x 1 word, 1x 2 words)
   // -----
   //   34
-  EXPECT_EQ(34 * WORDS, segment->getSize());
+  ArrayPtr<const ArrayPtr<const word>> segments = arena.getSegmentsForOutput();
+  ASSERT_EQ(1u, segments.size());
+  EXPECT_EQ(34u, segments[0].size());
 
   checkStruct(builder);
   checkStruct(builder.asReader());
@@ -295,34 +298,35 @@ TEST(WireFormat, StructRoundTrip_OneSegment) {
 }
 
 TEST(WireFormat, StructRoundTrip_OneSegmentPerAllocation) {
-  std::unique_ptr<MessageBuilder> message = newMallocMessage(1 * WORDS);
-  SegmentBuilder* segment = message->getSegmentWithAvailable(1 * WORDS);
+  MallocAllocator allocator(1);
+  BuilderArena arena(&allocator);
+  SegmentBuilder* segment = arena.getSegmentWithAvailable(1 * WORDS);
   word* rootLocation = segment->allocate(1 * WORDS);
 
   StructBuilder builder = StructBuilder::initRoot(segment, rootLocation, STRUCT_DEFAULT.words);
   setupStruct(builder);
 
   // Verify that we made 15 segments.
-  ASSERT_TRUE(message->tryGetSegment(SegmentId(14)) != nullptr);
-  EXPECT_EQ(nullptr, message->tryGetSegment(SegmentId(15)));
+  ArrayPtr<const ArrayPtr<const word>> segments = arena.getSegmentsForOutput();
+  ASSERT_EQ(15u, segments.size());
 
   // Check that each segment has the expected size.  Recall that the first word of each segment will
   // actually be a reference to the first thing allocated within that segment.
-  EXPECT_EQ( 1 * WORDS, message->getSegment(SegmentId( 0))->getSize());  // root ref
-  EXPECT_EQ( 7 * WORDS, message->getSegment(SegmentId( 1))->getSize());  // root struct
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId( 2))->getSize());  // sub-struct
-  EXPECT_EQ( 3 * WORDS, message->getSegment(SegmentId( 3))->getSize());  // 3-element int32 list
-  EXPECT_EQ(10 * WORDS, message->getSegment(SegmentId( 4))->getSize());  // struct list
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId( 5))->getSize());  // struct list substruct 1
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId( 6))->getSize());  // struct list substruct 2
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId( 7))->getSize());  // struct list substruct 3
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId( 8))->getSize());  // struct list substruct 4
-  EXPECT_EQ( 6 * WORDS, message->getSegment(SegmentId( 9))->getSize());  // list list
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId(10))->getSize());  // list list sublist 1
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId(11))->getSize());  // list list sublist 2
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId(12))->getSize());  // list list sublist 3
-  EXPECT_EQ( 2 * WORDS, message->getSegment(SegmentId(13))->getSize());  // list list sublist 4
-  EXPECT_EQ( 3 * WORDS, message->getSegment(SegmentId(14))->getSize());  // list list sublist 5
+  EXPECT_EQ( 1u, segments[ 0].size());  // root ref
+  EXPECT_EQ( 7u, segments[ 1].size());  // root struct
+  EXPECT_EQ( 2u, segments[ 2].size());  // sub-struct
+  EXPECT_EQ( 3u, segments[ 3].size());  // 3-element int32 list
+  EXPECT_EQ(10u, segments[ 4].size());  // struct list
+  EXPECT_EQ( 2u, segments[ 5].size());  // struct list substruct 1
+  EXPECT_EQ( 2u, segments[ 6].size());  // struct list substruct 2
+  EXPECT_EQ( 2u, segments[ 7].size());  // struct list substruct 3
+  EXPECT_EQ( 2u, segments[ 8].size());  // struct list substruct 4
+  EXPECT_EQ( 6u, segments[ 9].size());  // list list
+  EXPECT_EQ( 2u, segments[10].size());  // list list sublist 1
+  EXPECT_EQ( 2u, segments[11].size());  // list list sublist 2
+  EXPECT_EQ( 2u, segments[12].size());  // list list sublist 3
+  EXPECT_EQ( 2u, segments[13].size());  // list list sublist 4
+  EXPECT_EQ( 3u, segments[14].size());  // list list sublist 5
 
   checkStruct(builder);
   checkStruct(builder.asReader());
@@ -330,25 +334,26 @@ TEST(WireFormat, StructRoundTrip_OneSegmentPerAllocation) {
 }
 
 TEST(WireFormat, StructRoundTrip_MultipleSegmentsWithMultipleAllocations) {
-  std::unique_ptr<MessageBuilder> message = newMallocMessage(8 * WORDS);
-  SegmentBuilder* segment = message->getSegmentWithAvailable(1 * WORDS);
+  MallocAllocator allocator(8);
+  BuilderArena arena(&allocator);
+  SegmentBuilder* segment = arena.getSegmentWithAvailable(1 * WORDS);
   word* rootLocation = segment->allocate(1 * WORDS);
 
   StructBuilder builder = StructBuilder::initRoot(segment, rootLocation, STRUCT_DEFAULT.words);
   setupStruct(builder);
 
   // Verify that we made 6 segments.
-  ASSERT_TRUE(message->tryGetSegment(SegmentId(5)) != nullptr);
-  EXPECT_EQ(nullptr, message->tryGetSegment(SegmentId(6)));
+  ArrayPtr<const ArrayPtr<const word>> segments = arena.getSegmentsForOutput();
+  ASSERT_EQ(6u, segments.size());
 
   // Check that each segment has the expected size.  Recall that each object will be prefixed by an
   // extra word if its parent is in a different segment.
-  EXPECT_EQ( 8 * WORDS, message->getSegment(SegmentId(0))->getSize());  // root ref + struct + sub
-  EXPECT_EQ( 3 * WORDS, message->getSegment(SegmentId(1))->getSize());  // 3-element int32 list
-  EXPECT_EQ(10 * WORDS, message->getSegment(SegmentId(2))->getSize());  // struct list
-  EXPECT_EQ( 8 * WORDS, message->getSegment(SegmentId(3))->getSize());  // struct list substructs
-  EXPECT_EQ( 8 * WORDS, message->getSegment(SegmentId(4))->getSize());  // list list + sublist 1,2
-  EXPECT_EQ( 7 * WORDS, message->getSegment(SegmentId(5))->getSize());  // list list sublist 3,4,5
+  EXPECT_EQ( 8u, segments[0].size());  // root ref + struct + sub
+  EXPECT_EQ( 3u, segments[1].size());  // 3-element int32 list
+  EXPECT_EQ(10u, segments[2].size());  // struct list
+  EXPECT_EQ( 8u, segments[3].size());  // struct list substructs
+  EXPECT_EQ( 8u, segments[4].size());  // list list + sublist 1,2
+  EXPECT_EQ( 7u, segments[5].size());  // list list sublist 3,4,5
 
   checkStruct(builder);
   checkStruct(builder.asReader());

c++/src/capnproto/wire-format.h

@@ -34,11 +34,6 @@
 #include "type-safety.h"
 #include "blob.h"
 
-namespace capnproto {
-  class SegmentReader;
-  class SegmentBuilder;
-}
-
 namespace capnproto {
 namespace internal {
 
@@ -52,6 +47,8 @@ class ListBuilder;
 class ListReader;
 struct WireReference;
 struct WireHelpers;
+class SegmentReader;
+class SegmentBuilder;
 
 // -------------------------------------------------------------------
 
@@ -85,6 +82,7 @@ public:
   inline StructBuilder(): segment(nullptr), data(nullptr), references(nullptr) {}
 
   static StructBuilder initRoot(SegmentBuilder* segment, word* location, const word* defaultValue);
+  static StructBuilder getRoot(SegmentBuilder* segment, word* location, const word* defaultValue);
 
   template <typename T>
   CAPNPROTO_ALWAYS_INLINE(T getDataField(ElementCount offset) const);