Factor Pointer{Reader,Builder} out from {Struct,List}{Reader,Builder}. Will…

Factor Pointer{Reader,Builder} out from {Struct,List}{Reader,Builder}.  Will make it easier to deal with Object fields.

c++/src/capnp/compiler/capnpc-c++.c++

@@ -581,7 +581,8 @@ private:
                               slot.offset, " * ::capnp::ELEMENTS) != 0");
                     case Section::POINTERS:
                       return kj::strTree(
-                          "!_reader.isPointerFieldNull(", slot.offset, " * ::capnp::POINTERS)");
+                          "!_reader.getPointerField(", slot.offset,
+                              " * ::capnp::POINTERS).isNull()");
                   }
                   KJ_UNREACHABLE;
                 }, "\n      || "), ";\n"
@@ -599,7 +600,8 @@ private:
                               slot.offset, " * ::capnp::ELEMENTS) != 0");
                     case Section::POINTERS:
                       return kj::strTree(
-                          "!_builder.isPointerFieldNull(", slot.offset, " * ::capnp::POINTERS)");
+                          "!_builder.getPointerField(", slot.offset,
+                              " * ::capnp::POINTERS).isNull()");
                   }
                   KJ_UNREACHABLE;
                 }, "\n      || "), ";\n"
@@ -624,7 +626,8 @@ private:
                               slot.offset, " * ::capnp::ELEMENTS, 0);\n");
                     case Section::POINTERS:
                       return kj::strTree(
-                          "  _builder.clearPointer(", slot.offset, " * ::capnp::POINTERS);\n");
+                          "  _builder.getPointerField(", slot.offset,
+                              " * ::capnp::POINTERS).clear();\n");
                   }
                   KJ_UNREACHABLE;
                 },
@@ -835,11 +838,11 @@ private:
             kj::mv(unionDiscrim.isDefs),
             "inline bool ", scope, "Reader::has", titleCase, "() const {\n",
             unionDiscrim.has,
-            "  return !_reader.isPointerFieldNull(", offset, " * ::capnp::POINTERS);\n"
+            "  return !_reader.getPointerField(", offset, " * ::capnp::POINTERS).isNull();\n"
             "}\n"
             "inline bool ", scope, "Builder::has", titleCase, "() {\n",
             unionDiscrim.has,
-            "  return !_builder.isPointerFieldNull(", offset, " * ::capnp::POINTERS);\n"
+            "  return !_builder.getPointerField(", offset, " * ::capnp::POINTERS).isNull();\n"
             "}\n"
             "template <typename T>\n"
             "inline typename T::Reader ", scope, "Reader::get", titleCase, "() const {\n",
@@ -974,11 +977,11 @@ private:
             kj::mv(unionDiscrim.isDefs),
             "inline bool ", scope, "Reader::has", titleCase, "() const {\n",
             unionDiscrim.has,
-            "  return !_reader.isPointerFieldNull(", offset, " * ::capnp::POINTERS);\n"
+            "  return !_reader.getPointerField(", offset, " * ::capnp::POINTERS).isNull();\n"
             "}\n"
             "inline bool ", scope, "Builder::has", titleCase, "() {\n",
             unionDiscrim.has,
-            "  return !_builder.isPointerFieldNull(", offset, " * ::capnp::POINTERS);\n"
+            "  return !_builder.getPointerField(", offset, " * ::capnp::POINTERS).isNull();\n"
             "}\n"
             "inline ", type, "::Reader ", scope, "Reader::get", titleCase, "() const {\n",
             unionDiscrim.check,

c++/src/capnp/compiler/lexer.capnp.h

@@ -494,11 +494,11 @@ inline bool Token::Builder::isIdentifier() {
 }
 inline bool Token::Reader::hasIdentifier() const {
   if (which() != Token::IDENTIFIER) return false;
-  return !_reader.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline bool Token::Builder::hasIdentifier() {
   if (which() != Token::IDENTIFIER) return false;
-  return !_builder.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::Text::Reader Token::Reader::getIdentifier() const {
   KJ_IREQUIRE(which() == Token::IDENTIFIER,
@@ -546,11 +546,11 @@ inline bool Token::Builder::isStringLiteral() {
 }
 inline bool Token::Reader::hasStringLiteral() const {
   if (which() != Token::STRING_LITERAL) return false;
-  return !_reader.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline bool Token::Builder::hasStringLiteral() {
   if (which() != Token::STRING_LITERAL) return false;
-  return !_builder.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::Text::Reader Token::Reader::getStringLiteral() const {
   KJ_IREQUIRE(which() == Token::STRING_LITERAL,
@@ -668,11 +668,11 @@ inline bool Token::Builder::isOperator() {
 }
 inline bool Token::Reader::hasOperator() const {
   if (which() != Token::OPERATOR) return false;
-  return !_reader.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline bool Token::Builder::hasOperator() {
   if (which() != Token::OPERATOR) return false;
-  return !_builder.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::Text::Reader Token::Reader::getOperator() const {
   KJ_IREQUIRE(which() == Token::OPERATOR,
@@ -720,11 +720,11 @@ inline bool Token::Builder::isParenthesizedList() {
 }
 inline bool Token::Reader::hasParenthesizedList() const {
   if (which() != Token::PARENTHESIZED_LIST) return false;
-  return !_reader.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline bool Token::Builder::hasParenthesizedList() {
   if (which() != Token::PARENTHESIZED_LIST) return false;
-  return !_builder.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader Token::Reader::getParenthesizedList() const {
   KJ_IREQUIRE(which() == Token::PARENTHESIZED_LIST,
@@ -778,11 +778,11 @@ inline bool Token::Builder::isBracketedList() {
 }
 inline bool Token::Reader::hasBracketedList() const {
   if (which() != Token::BRACKETED_LIST) return false;
-  return !_reader.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline bool Token::Builder::hasBracketedList() {
   if (which() != Token::BRACKETED_LIST) return false;
-  return !_builder.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::List< ::capnp::List< ::capnp::compiler::Token>>::Reader Token::Reader::getBracketedList() const {
   KJ_IREQUIRE(which() == Token::BRACKETED_LIST,
@@ -878,10 +878,10 @@ inline Statement::Which Statement::Builder::which() {
 }
 
 inline bool Statement::Reader::hasTokens() const {
-  return !_reader.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline bool Statement::Builder::hasTokens() {
-  return !_builder.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::List< ::capnp::compiler::Token>::Reader Statement::Reader::getTokens() const {
   return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::get(
@@ -952,11 +952,11 @@ inline bool Statement::Builder::isBlock() {
 }
 inline bool Statement::Reader::hasBlock() const {
   if (which() != Statement::BLOCK) return false;
-  return !_reader.isPointerFieldNull(1 * ::capnp::POINTERS);
+  return !_reader.getPointerField(1 * ::capnp::POINTERS).isNull();
 }
 inline bool Statement::Builder::hasBlock() {
   if (which() != Statement::BLOCK) return false;
-  return !_builder.isPointerFieldNull(1 * ::capnp::POINTERS);
+  return !_builder.getPointerField(1 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::List< ::capnp::compiler::Statement>::Reader Statement::Reader::getBlock() const {
   KJ_IREQUIRE(which() == Statement::BLOCK,
@@ -997,10 +997,10 @@ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Statement>> Statement:
 }
 
 inline bool Statement::Reader::hasDocComment() const {
-  return !_reader.isPointerFieldNull(2 * ::capnp::POINTERS);
+  return !_reader.getPointerField(2 * ::capnp::POINTERS).isNull();
 }
 inline bool Statement::Builder::hasDocComment() {
-  return !_builder.isPointerFieldNull(2 * ::capnp::POINTERS);
+  return !_builder.getPointerField(2 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::Text::Reader Statement::Reader::getDocComment() const {
   return ::capnp::_::PointerHelpers< ::capnp::Text>::get(
@@ -1071,10 +1071,10 @@ inline void Statement::Builder::setEndByte( ::uint32_t value) {
 }
 
 inline bool LexedTokens::Reader::hasTokens() const {
-  return !_reader.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline bool LexedTokens::Builder::hasTokens() {
-  return !_builder.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::List< ::capnp::compiler::Token>::Reader LexedTokens::Reader::getTokens() const {
   return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Token>>::get(
@@ -1103,10 +1103,10 @@ inline ::capnp::Orphan< ::capnp::List< ::capnp::compiler::Token>> LexedTokens::B
 }
 
 inline bool LexedStatements::Reader::hasStatements() const {
-  return !_reader.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_reader.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline bool LexedStatements::Builder::hasStatements() {
-  return !_builder.isPointerFieldNull(0 * ::capnp::POINTERS);
+  return !_builder.getPointerField(0 * ::capnp::POINTERS).isNull();
 }
 inline  ::capnp::List< ::capnp::compiler::Statement>::Reader LexedStatements::Reader::getStatements() const {
   return ::capnp::_::PointerHelpers< ::capnp::List< ::capnp::compiler::Statement>>::get(

c++/src/capnp/dynamic.h

@@ -964,11 +964,11 @@ struct PointerHelpers<DynamicStruct, Kind::UNKNOWN> {
       StructBuilder builder, WirePointerCount index, StructSchema schema);
   static inline void adopt(StructBuilder builder, WirePointerCount index,
                            Orphan<DynamicStruct>&& value) {
-    builder.adopt(index, kj::mv(value.builder));
+    builder.getPointerField(index).adopt(kj::mv(value.builder));
   }
   static inline Orphan<DynamicStruct> disown(StructBuilder builder, WirePointerCount index,
                                              StructSchema schema) {
-    return Orphan<DynamicStruct>(schema, builder.disown(index));
+    return Orphan<DynamicStruct>(schema, builder.getPointerField(index).disown());
   }
 };
 
@@ -987,11 +987,11 @@ struct PointerHelpers<DynamicList, Kind::UNKNOWN> {
       StructBuilder builder, WirePointerCount index, ListSchema schema, uint size);
   static inline void adopt(StructBuilder builder, WirePointerCount index,
                            Orphan<DynamicList>&& value) {
-    builder.adopt(index, kj::mv(value.builder));
+    builder.getPointerField(index).adopt(kj::mv(value.builder));
   }
   static inline Orphan<DynamicList> disown(StructBuilder builder, WirePointerCount index,
                                            ListSchema schema) {
-    return Orphan<DynamicList>(schema, builder.disown(index));
+    return Orphan<DynamicList>(schema, builder.getPointerField(index).disown());
   }
 };
 
@@ -1003,10 +1003,10 @@ struct PointerHelpers<DynamicObject, Kind::UNKNOWN> {
       StructBuilder builder, WirePointerCount index, const DynamicObject::Reader& value);
   static inline void adopt(StructBuilder builder, WirePointerCount index,
                            Orphan<DynamicObject>&& value) {
-    builder.adopt(index, kj::mv(value.builder));
+    builder.getPointerField(index).adopt(kj::mv(value.builder));
   }
   static inline Orphan<DynamicObject> disown(StructBuilder builder, WirePointerCount index) {
-    return Orphan<DynamicObject>(builder.disown(index));
+    return Orphan<DynamicObject>(builder.getPointerField(index).disown());
   }
 };
 

c++/src/capnp/generated-header-support.h

@@ -47,24 +47,25 @@ template <typename T>
 struct PointerHelpers<T, Kind::STRUCT> {
   static inline typename T::Reader get(StructReader reader, WirePointerCount index,
                                        const word* defaultValue = nullptr) {
-    return typename T::Reader(reader.getStructField(index, defaultValue));
+    return typename T::Reader(reader.getPointerField(index).getStruct(defaultValue));
   }
   static inline typename T::Builder get(StructBuilder builder, WirePointerCount index,
                                         const word* defaultValue = nullptr) {
-    return typename T::Builder(builder.getStructField(index, structSize<T>(), defaultValue));
+    return typename T::Builder(
+        builder.getPointerField(index).getStruct(structSize<T>(), defaultValue));
   }
   static inline void set(StructBuilder builder, WirePointerCount index,
                          typename T::Reader value) {
-    builder.setStructField(index, value._reader);
+    builder.getPointerField(index).setStruct(value._reader);
   }
   static inline typename T::Builder init(StructBuilder builder, WirePointerCount index) {
-    return typename T::Builder(builder.initStructField(index, structSize<T>()));
+    return typename T::Builder(builder.getPointerField(index).initStruct(structSize<T>()));
   }
   static inline void adopt(StructBuilder builder, WirePointerCount index, Orphan<T>&& value) {
-    builder.adopt(index, kj::mv(value.builder));
+    builder.getPointerField(index).adopt(kj::mv(value.builder));
   }
   static inline Orphan<T> disown(StructBuilder builder, WirePointerCount index) {
-    return Orphan<T>(builder.disown(index));
+    return Orphan<T>(builder.getPointerField(index).disown());
   }
 };
 
@@ -80,7 +81,7 @@ struct PointerHelpers<List<T>, Kind::LIST> {
   }
   static inline void set(StructBuilder builder, WirePointerCount index,
                          typename List<T>::Reader value) {
-    builder.setListField(index, value.reader);
+    builder.getPointerField(index).setList(value.reader);
   }
   template <typename U>
   static void set(StructBuilder builder, WirePointerCount index, std::initializer_list<U> value) {
@@ -95,10 +96,10 @@ struct PointerHelpers<List<T>, Kind::LIST> {
     return typename List<T>::Builder(List<T>::initAsFieldOf(builder, index, size));
   }
   static inline void adopt(StructBuilder builder, WirePointerCount index, Orphan<List<T>>&& value) {
-    builder.adopt(index, kj::mv(value.builder));
+    builder.getPointerField(index).adopt(kj::mv(value.builder));
   }
   static inline Orphan<List<T>> disown(StructBuilder builder, WirePointerCount index) {
-    return Orphan<List<T>>(builder.disown(index));
+    return Orphan<List<T>>(builder.getPointerField(index).disown());
   }
 };
 
@@ -107,24 +108,24 @@ struct PointerHelpers<T, Kind::BLOB> {
   static inline typename T::Reader get(StructReader reader, WirePointerCount index,
                                        const void* defaultValue = nullptr,
                                        uint defaultBytes = 0) {
-    return reader.getBlobField<T>(index, defaultValue, defaultBytes * BYTES);
+    return reader.getPointerField(index).getBlob<T>(defaultValue, defaultBytes * BYTES);
   }
   static inline typename T::Builder get(StructBuilder builder, WirePointerCount index,
                                         const void* defaultValue = nullptr,
                                         uint defaultBytes = 0) {
-    return builder.getBlobField<T>(index, defaultValue, defaultBytes * BYTES);
+    return builder.getPointerField(index).getBlob<T>(defaultValue, defaultBytes * BYTES);
   }
   static inline void set(StructBuilder builder, WirePointerCount index, typename T::Reader value) {
-    builder.setBlobField<T>(index, value);
+    builder.getPointerField(index).setBlob<T>(value);
   }
   static inline typename T::Builder init(StructBuilder builder, WirePointerCount index, uint size) {
-    return builder.initBlobField<T>(index, size * BYTES);
+    return builder.getPointerField(index).initBlob<T>(size * BYTES);
   }
   static inline void adopt(StructBuilder builder, WirePointerCount index, Orphan<T>&& value) {
-    builder.adopt(index, kj::mv(value.builder));
+    builder.getPointerField(index).adopt(kj::mv(value.builder));
   }
   static inline Orphan<T> disown(StructBuilder builder, WirePointerCount index) {
-    return Orphan<T>(builder.disown(index));
+    return Orphan<T>(builder.getPointerField(index).disown());
   }
 };
 
@@ -139,7 +140,7 @@ struct PointerHelpers<UncheckedMessage> {
   // encoded schemas.
 
   static inline const word* get(StructReader reader, WirePointerCount index) {
-    return reader.getUncheckedPointer(index);
+    return reader.getPointerField(index).getUnchecked();
   }
 };
 

c++/src/capnp/layout-test.c++

@@ -120,13 +120,14 @@ static void setupStruct(StructBuilder builder) {
   builder.setDataField<bool>(127 * ELEMENTS, false);
 
   {
-    StructBuilder subStruct = builder.initStructField(
-        0 * POINTERS, StructSize(1 * WORDS, 0 * POINTERS, FieldSize::EIGHT_BYTES));
+    StructBuilder subStruct = builder.getPointerField(0 * POINTERS).initStruct(
+        StructSize(1 * WORDS, 0 * POINTERS, FieldSize::EIGHT_BYTES));
     subStruct.setDataField<uint32_t>(0 * ELEMENTS, 123);
   }
 
   {
-    ListBuilder list = builder.initListField(1 * POINTERS, FieldSize::FOUR_BYTES, 3 * ELEMENTS);
+    ListBuilder list = builder.getPointerField(1 * POINTERS)
+        .initList(FieldSize::FOUR_BYTES, 3 * ELEMENTS);
     EXPECT_EQ(3 * ELEMENTS, list.size());
     list.setDataElement<int32_t>(0 * ELEMENTS, 200);
     list.setDataElement<int32_t>(1 * ELEMENTS, 201);
@@ -134,24 +135,25 @@ static void setupStruct(StructBuilder builder) {
   }
 
   {
-    ListBuilder list = builder.initStructListField(
-        2 * POINTERS, 4 * ELEMENTS, STRUCTLIST_ELEMENT_SIZE);
+    ListBuilder list = builder.getPointerField(2 * POINTERS).initStructList(
+        4 * ELEMENTS, STRUCTLIST_ELEMENT_SIZE);
     EXPECT_EQ(4 * ELEMENTS, list.size());
     for (int i = 0; i < 4; i++) {
       StructBuilder element = list.getStructElement(i * ELEMENTS);
       element.setDataField<int32_t>(0 * ELEMENTS, 300 + i);
-      element.initStructField(0 * POINTERS,
-                              StructSize(1 * WORDS, 0 * POINTERS, FieldSize::EIGHT_BYTES))
+      element.getPointerField(0 * POINTERS)
+             .initStruct(StructSize(1 * WORDS, 0 * POINTERS, FieldSize::EIGHT_BYTES))
              .setDataField<int32_t>(0 * ELEMENTS, 400 + i);
     }
   }
 
   {
-    ListBuilder list = builder.initListField(3 * POINTERS, FieldSize::POINTER, 5 * ELEMENTS);
+    ListBuilder list = builder.getPointerField(3 * POINTERS)
+                              .initList(FieldSize::POINTER, 5 * ELEMENTS);
     EXPECT_EQ(5 * ELEMENTS, list.size());
     for (uint i = 0; i < 5; i++) {
-      ListBuilder element = list.initListElement(
-          i * ELEMENTS, FieldSize::TWO_BYTES, (i + 1) * ELEMENTS);
+      ListBuilder element = list.getPointerElement(i * ELEMENTS)
+                                .initList(FieldSize::TWO_BYTES, (i + 1) * ELEMENTS);
       EXPECT_EQ((i + 1) * ELEMENTS, element.size());
       for (uint j = 0; j <= i; j++) {
         element.setDataElement<uint16_t>(j * ELEMENTS, 500 + j);
@@ -175,14 +177,15 @@ static void checkStruct(StructBuilder builder) {
   EXPECT_FALSE(builder.getDataField<bool>(127 * ELEMENTS));
 
   {
-    StructBuilder subStruct = builder.getStructField(
-        0 * POINTERS, StructSize(1 * WORDS, 0 * POINTERS, FieldSize::EIGHT_BYTES),
+    StructBuilder subStruct = builder.getPointerField(0 * POINTERS).getStruct(
+        StructSize(1 * WORDS, 0 * POINTERS, FieldSize::EIGHT_BYTES),
         SUBSTRUCT_DEFAULT.words);
     EXPECT_EQ(123u, subStruct.getDataField<uint32_t>(0 * ELEMENTS));
   }
 
   {
-    ListBuilder list = builder.getListField(1 * POINTERS, FieldSize::FOUR_BYTES, nullptr);
+    ListBuilder list = builder.getPointerField(1 * POINTERS)
+                              .getList(FieldSize::FOUR_BYTES, nullptr);
     ASSERT_EQ(3 * ELEMENTS, list.size());
     EXPECT_EQ(200, list.getDataElement<int32_t>(0 * ELEMENTS));
     EXPECT_EQ(201, list.getDataElement<int32_t>(1 * ELEMENTS));
@@ -190,24 +193,26 @@ static void checkStruct(StructBuilder builder) {
   }
 
   {
-    ListBuilder list = builder.getStructListField(2 * POINTERS, STRUCTLIST_ELEMENT_SIZE, nullptr);
+    ListBuilder list = builder.getPointerField(2 * POINTERS)
+                              .getStructList(STRUCTLIST_ELEMENT_SIZE, nullptr);
     ASSERT_EQ(4 * ELEMENTS, list.size());
     for (int i = 0; i < 4; i++) {
       StructBuilder element = list.getStructElement(i * ELEMENTS);
       EXPECT_EQ(300 + i, element.getDataField<int32_t>(0 * ELEMENTS));
       EXPECT_EQ(400 + i,
-          element.getStructField(0 * POINTERS,
-                                 StructSize(1 * WORDS, 0 * POINTERS, FieldSize::EIGHT_BYTES),
+          element.getPointerField(0 * POINTERS)
+                 .getStruct(StructSize(1 * WORDS, 0 * POINTERS, FieldSize::EIGHT_BYTES),
                             STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT.words)
                  .getDataField<int32_t>(0 * ELEMENTS));
     }
   }
 
   {
-    ListBuilder list = builder.getListField(3 * POINTERS, FieldSize::POINTER, nullptr);
+    ListBuilder list = builder.getPointerField(3 * POINTERS).getList(FieldSize::POINTER, nullptr);
     ASSERT_EQ(5 * ELEMENTS, list.size());
     for (uint i = 0; i < 5; i++) {
-      ListBuilder element = list.getListElement(i * ELEMENTS, FieldSize::TWO_BYTES);
+      ListBuilder element = list.getPointerElement(i * ELEMENTS)
+                                .getList(FieldSize::TWO_BYTES, nullptr);
       ASSERT_EQ((i + 1) * ELEMENTS, element.size());
       for (uint j = 0; j <= i; j++) {
         EXPECT_EQ(500u + j, element.getDataElement<uint16_t>(j * ELEMENTS));
@@ -231,12 +236,13 @@ static void checkStruct(StructReader reader) {
   EXPECT_FALSE(reader.getDataField<bool>(127 * ELEMENTS));
 
   {
-    StructReader subStruct = reader.getStructField(0 * POINTERS, SUBSTRUCT_DEFAULT.words);
+    StructReader subStruct = reader.getPointerField(0 * POINTERS)
+                                   .getStruct(SUBSTRUCT_DEFAULT.words);
     EXPECT_EQ(123u, subStruct.getDataField<uint32_t>(0 * ELEMENTS));
   }
 
   {
-    ListReader list = reader.getListField(1 * POINTERS, FieldSize::FOUR_BYTES, nullptr);
+    ListReader list = reader.getPointerField(1 * POINTERS).getList(FieldSize::FOUR_BYTES, nullptr);
     ASSERT_EQ(3 * ELEMENTS, list.size());
     EXPECT_EQ(200, list.getDataElement<int32_t>(0 * ELEMENTS));
     EXPECT_EQ(201, list.getDataElement<int32_t>(1 * ELEMENTS));
@@ -244,22 +250,25 @@ static void checkStruct(StructReader reader) {
   }
 
   {
-    ListReader list = reader.getListField(2 * POINTERS, FieldSize::INLINE_COMPOSITE, nullptr);
+    ListReader list = reader.getPointerField(2 * POINTERS)
+                            .getList(FieldSize::INLINE_COMPOSITE, nullptr);
     ASSERT_EQ(4 * ELEMENTS, list.size());
     for (int i = 0; i < 4; i++) {
       StructReader element = list.getStructElement(i * ELEMENTS);
       EXPECT_EQ(300 + i, element.getDataField<int32_t>(0 * ELEMENTS));
       EXPECT_EQ(400 + i,
-          element.getStructField(0 * POINTERS, STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT.words)
+          element.getPointerField(0 * POINTERS)
+                 .getStruct(STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT.words)
                  .getDataField<int32_t>(0 * ELEMENTS));
     }
   }
 
   {
-    ListReader list = reader.getListField(3 * POINTERS, FieldSize::POINTER, nullptr);
+    ListReader list = reader.getPointerField(3 * POINTERS).getList(FieldSize::POINTER, nullptr);
     ASSERT_EQ(5 * ELEMENTS, list.size());
     for (uint i = 0; i < 5; i++) {
-      ListReader element = list.getListElement(i * ELEMENTS, FieldSize::TWO_BYTES);
+      ListReader element = list.getPointerElement(i * ELEMENTS)
+                               .getList(FieldSize::TWO_BYTES, nullptr);
       ASSERT_EQ((i + 1) * ELEMENTS, element.size());
       for (uint j = 0; j <= i; j++) {
         EXPECT_EQ(500u + j, element.getDataElement<uint16_t>(j * ELEMENTS));