Rename user-define structure annotation macros for better clarity.

NOP_MEMBERS -> NOP_STRUCTURE
NOP_STRUCTURE -> NOP_EXTERNAL_STRUCTURE
NOP_TEMPLATE -> NOP_EXTERNAL_TEMPLATE

Author: eieio

examples/interface.cpp

@@ -115,7 +115,7 @@ class PhoneNumber {
   std::string number_;
   Type type_{Type::Other};
 
-  NOP_MEMBERS(PhoneNumber, number_, type_);
+  NOP_STRUCTURE(PhoneNumber, number_, type_);
 };
 
 // A simple customer record with basic identity and contact information,
@@ -166,8 +166,8 @@ class Customer {
   std::string address_;
   std::vector<PhoneNumber> phone_numbers_;
 
-  NOP_MEMBERS(Customer, last_name_, first_name_, middle_name_, address_,
-              phone_numbers_);
+  NOP_STRUCTURE(Customer, last_name_, first_name_, middle_name_, address_,
+                phone_numbers_);
 };
 
 // Type for unique customer ids.

examples/pipe.cpp

@@ -21,8 +21,8 @@
 #include <utility>
 
 #include <nop/serializer.h>
-#include <nop/structure.h>
 #include <nop/status.h>
+#include <nop/structure.h>
 #include <nop/types/file_handle.h>
 #include <nop/types/result.h>
 #include <nop/utility/die.h>
@@ -71,7 +71,7 @@ struct Channel {
 // Defines the format of request messages sent from parent to child.
 struct Request {
   std::uint32_t request_bytes{0};
-  NOP_MEMBERS(Request, request_bytes);
+  NOP_STRUCTURE(Request, request_bytes);
 };
 
 // Defines the errors that may be returned from child to parent.
@@ -176,7 +176,8 @@ int HandleParent(Channel channel) {
   std::cout << "Parent sending message..." << std::endl;
 
   const std::uint32_t kRequestBytes = 32;
-  channel.Write(Request{kRequestBytes}) || Die("Parent failed to write request");
+  channel.Write(Request{kRequestBytes}) ||
+      Die("Parent failed to write request");
 
   Response response;
   channel.Read(&response) || Die("Parent failed to read response");

examples/simple_protocol.cpp

@@ -80,7 +80,7 @@ struct Header {
 
   // Make this header type serializable by describing it to the serialization
   // engine..
-  NOP_MEMBERS(Header, magic, version_major, version_minor);
+  NOP_STRUCTURE(Header, magic, version_major, version_minor);
 };
 
 // Protocol type for the header of the message.

examples/stream.cpp

@@ -41,16 +41,16 @@ using nop::StringToHex;
 //
 
 // Here we describe struct tm from the standard library, which is code we don't
-// own and can't change to include an annotation. The NOP_STRUCTURE() macro
-// annotates types we don't own so that the serializer can understand how to
-// work with them. The annotation must be in the same namespace as the structure
-// is originally defined in.
-// NOTE: struct tm is orignally defined in the global namespace, even though the
-// header <ctime> also aliases it into the std namespace. The annotation must be
-// defined in the ORIGINAL namespace of the annotated type because the compiler
-// only considers the original namespace during name lookup.
-NOP_STRUCTURE(tm, tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday,
-              tm_yday, tm_isdst);
+// own and can't change to include an annotation. The NOP_EXTERNAL_STRUCTURE()
+// macro annotates types we don't own so that the serializer can understand how
+// to work with them. The annotation must be in the same namespace as the
+// structure is originally defined in. NOTE: struct tm is orignally defined in
+// the global namespace, even though the header <ctime> also aliases it into the
+// std namespace. The annotation must be defined in the ORIGINAL namespace of
+// the annotated type because the compiler only considers the original namespace
+// during name lookup.
+NOP_EXTERNAL_STRUCTURE(tm, tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year,
+                       tm_wday, tm_yday, tm_isdst);
 
 namespace {
 
@@ -76,7 +76,7 @@ class UserDefinedA {
   std::string a_;
   std::vector<int> b_;
 
-  NOP_MEMBERS(UserDefinedA, a_, b_);
+  NOP_STRUCTURE(UserDefinedA, a_, b_);
 };
 
 // All enum and enum class types are serializable.
@@ -97,7 +97,7 @@ struct UserDefinedB {
   EnumA f;
   Optional<std::string> g;
 
-  NOP_MEMBERS(UserDefinedB, a, b, c, d, e, f, g);
+  NOP_STRUCTURE(UserDefinedB, a, b, c, d, e, f, g);
 };
 
 // Prints a struct tm to the given stream.

examples/variant.cpp

@@ -50,15 +50,15 @@ struct MessageA {
   std::uint32_t a;
   std::string b;
   std::vector<short> c;
-  NOP_MEMBERS(MessageA, a, b, c);
+  NOP_STRUCTURE(MessageA, a, b, c);
 };
 
 // Second user-defined type.
 struct MessageB {
   std::uint64_t x;
   std::vector<int> y;
   std::pair<std::string, std::string> z;
-  NOP_MEMBERS(MessageB, x, y, z);
+  NOP_STRUCTURE(MessageB, x, y, z);
 };
 
 // Utility to print MessageA to the debug stream.

include/nop/structure.h

@@ -22,40 +22,15 @@
 
 namespace nop {
 
-// Generates a pair of template arguments (member pointer type and value) to be
-// passed to MemberPointer<MemberPointerType, MemberPointerValue, ...> from the
-// given type name and member name.
-#define _NOP_MEMBER_POINTER(type, member) decltype(&type::member), &type::member
-
-// Generates a MemberPointer type definition, given a type name and a variable
-// number of member names. The first member name is handled here, while the
-// remaining member names are passed to _NOP_MEMBER_POINTER_NEXT for recursive
-// expansion.
-#define _NOP_MEMBER_POINTER_FIRST(type, ...)                                  \
-  ::nop::MemberPointer<_NOP_MEMBER_POINTER(type, _NOP_FIRST_ARG(__VA_ARGS__)) \
-                           _NOP_MEMBER_POINTER_NEXT(                          \
-                               type, _NOP_REST_ARG(__VA_ARGS__))>
-
-// Recursively handles the remaining member names in the template argument list
-// for MemberPointer.
-#define _NOP_MEMBER_POINTER_NEXT(type, ...)                 \
-  _NOP_IF_ELSE(_NOP_HAS_ARGS(__VA_ARGS__))                  \
-  (, _NOP_MEMBER_POINTER(type, _NOP_FIRST_ARG(__VA_ARGS__)) \
-         _NOP_DEFER2(__NOP_MEMBER_POINTER_NEXT)()(          \
-             type, _NOP_REST_ARG(__VA_ARGS__)))(/*done*/)
-
-// Indirection to enable recursive macro expansion of _NOP_MEMBER_POINTER_NEXT.
-#define __NOP_MEMBER_POINTER_NEXT() _NOP_MEMBER_POINTER_NEXT
-
-// Defines a list of MemberPointer types given a type and list of member names.
-#define NOP_MEMBER_LIST(type, ...) \
-  NOP_MAP_ARGS(_NOP_MEMBER_POINTER_FIRST, (type), __VA_ARGS__)
+//
+// User-defined structures are structs or classes that have been annotated so
+// that the serialization engine understands how to read and write them.
 
 // Defines the set of members belonging to a type that should be
-// serialized/deserialized. This macro should be called once within the
+// serialized/deserialized. This macro must be inkoked once within the
 // struct/class definition, preferrably in the private section for classes with
 // private data.
-#define NOP_MEMBERS(type, ... /*members*/)    \
+#define NOP_STRUCTURE(type, ... /*members*/)  \
   template <typename, typename>               \
   friend struct ::nop::Encoding;              \
   template <typename, typename>               \
@@ -67,7 +42,7 @@ namespace nop {
 // Defines the set of members belonging to a type that should be
 // serialized/deserialized without changing the type itself. This is useful for
 // making external library types with public data serializable.
-#define NOP_STRUCTURE(type, ... /*members*/)                                  \
+#define NOP_EXTERNAL_STRUCTURE(type, ... /*members*/)                         \
   template <typename>                                                         \
   struct NOP__MEMBER_TRAITS;                                                  \
   template <>                                                                 \
@@ -77,8 +52,8 @@ namespace nop {
   NOP__MEMBER_TRAITS<type> __attribute__((used))                              \
       NOP__GetExternalMemberTraits(type*)
 
-// Similar to NOP_STRUCTURE but for template types.
-#define NOP_TEMPLATE(type, ... /*members*/)                           \
+// Similar to NOP_EXTERNAL_STRUCTURE but for template types.
+#define NOP_EXTERNAL_TEMPLATE(type, ... /*members*/)                  \
   template <typename>                                                 \
   struct NOP__MEMBER_TRAITS;                                          \
   template <typename... Ts>                                           \
@@ -90,6 +65,39 @@ namespace nop {
   NOP__MEMBER_TRAITS<type<Ts...>> __attribute__((used))               \
       NOP__GetExternalMemberTraits(type<Ts...>*)
 
+//
+// Utility macros used by the macros above.
+//
+
+// Generates a pair of template arguments (member pointer type and value) to be
+// passed to MemberPointer<MemberPointerType, MemberPointerValue, ...> from the
+// given type name and member name.
+#define _NOP_MEMBER_POINTER(type, member) decltype(&type::member), &type::member
+
+// Generates a MemberPointer type definition, given a type name and a variable
+// number of member names. The first member name is handled here, while the
+// remaining member names are passed to _NOP_MEMBER_POINTER_NEXT for recursive
+// expansion.
+#define _NOP_MEMBER_POINTER_FIRST(type, ...)                                  \
+  ::nop::MemberPointer<_NOP_MEMBER_POINTER(type, _NOP_FIRST_ARG(__VA_ARGS__)) \
+                           _NOP_MEMBER_POINTER_NEXT(                          \
+                               type, _NOP_REST_ARG(__VA_ARGS__))>
+
+// Recursively handles the remaining member names in the template argument list
+// for MemberPointer.
+#define _NOP_MEMBER_POINTER_NEXT(type, ...)                 \
+  _NOP_IF_ELSE(_NOP_HAS_ARGS(__VA_ARGS__))                  \
+  (, _NOP_MEMBER_POINTER(type, _NOP_FIRST_ARG(__VA_ARGS__)) \
+         _NOP_DEFER2(__NOP_MEMBER_POINTER_NEXT)()(          \
+             type, _NOP_REST_ARG(__VA_ARGS__)))(/*done*/)
+
+// Indirection to enable recursive macro expansion of _NOP_MEMBER_POINTER_NEXT.
+#define __NOP_MEMBER_POINTER_NEXT() _NOP_MEMBER_POINTER_NEXT
+
+// Defines a list of MemberPointer types given a type and list of member names.
+#define NOP_MEMBER_LIST(type, ...) \
+  NOP_MAP_ARGS(_NOP_MEMBER_POINTER_FIRST, (type), __VA_ARGS__)
+
 }  // namespace nop
 
 #endif  // LIBNOP_INCLUDE_NOP_STRUCTURE_H_

test/fungible_tests.cpp

@@ -567,54 +567,54 @@ namespace {
 struct UserDefinedA {
   std::array<int, 10> a;
   std::array<float, 20> b;
-  NOP_MEMBERS(UserDefinedA, a, b);
+  NOP_STRUCTURE(UserDefinedA, a, b);
 };
 
 struct UserDefinedB1 {
   std::array<int, 10> a;
   float b[20];
-  NOP_MEMBERS(UserDefinedB1, a, b);
+  NOP_STRUCTURE(UserDefinedB1, a, b);
 };
 
 struct UserDefinedB2 {
   int a[10];
   float b[20];
-  NOP_MEMBERS(UserDefinedB2, a, b);
+  NOP_STRUCTURE(UserDefinedB2, a, b);
 };
 
 struct UserDefinedC {
   int a[10];
   std::string b;
-  NOP_MEMBERS(UserDefinedC, a, b);
+  NOP_STRUCTURE(UserDefinedC, a, b);
 };
 
 struct UserDefinedD {
   int a[10];
-  NOP_MEMBERS(UserDefinedD, a);
+  NOP_STRUCTURE(UserDefinedD, a);
 };
 
 struct UserDefinedE {
   int a[10];
   float b[20];
   int c;
-  NOP_MEMBERS(UserDefinedE, a, b, c);
+  NOP_STRUCTURE(UserDefinedE, a, b, c);
 };
 
 struct UserDefinedF1 {
   std::vector<int> a;
-  NOP_MEMBERS(UserDefinedF1, a);
+  NOP_STRUCTURE(UserDefinedF1, a);
 };
 
 struct UserDefinedF2 {
   int a[10];
   int b;
-  NOP_MEMBERS(UserDefinedF2, (a, b));
+  NOP_STRUCTURE(UserDefinedF2, (a, b));
 };
 
 struct UserDefinedF3 {
   std::array<int, 10> a;
   int b;
-  NOP_MEMBERS(UserDefinedF3, (a, b));
+  NOP_STRUCTURE(UserDefinedF3, (a, b));
 };
 
 }  // anonymous namespace

test/interface_tests.cpp

@@ -55,14 +55,14 @@ struct MessageA {
   int a;
   std::string b;
 
-  NOP_MEMBERS(MessageA, a, b);
+  NOP_STRUCTURE(MessageA, a, b);
 };
 
 struct MessageB {
   float a;
   std::vector<int> b;
 
-  NOP_MEMBERS(MessageB, a, b);
+  NOP_STRUCTURE(MessageB, a, b);
 };
 
 struct TestInterface : Interface<TestInterface> {

test/serializer_tests.cpp

@@ -63,7 +63,7 @@ struct TestA {
   }
 
  private:
-  NOP_MEMBERS(TestA, a, b);
+  NOP_STRUCTURE(TestA, a, b);
 };
 
 enum class EnumA : std::uint8_t {
@@ -82,11 +82,11 @@ struct TestB {
   }
 
  private:
-  NOP_MEMBERS(TestB, a, b);
+  NOP_STRUCTURE(TestB, a, b);
 };
 
 struct TestC {
-  NOP_MEMBERS(TestC);
+  NOP_STRUCTURE(TestC);
 };
 
 struct TestD {
@@ -98,7 +98,7 @@ struct TestD {
     return a == other.a && b == other.b && c == other.c;
   }
 };
-NOP_STRUCTURE(TestD, a, b, c);
+NOP_EXTERNAL_STRUCTURE(TestD, a, b, c);
 
 template <typename T>
 struct TestE {
@@ -109,7 +109,7 @@ struct TestE {
     return a == other.a && b == other.b;
   }
 };
-NOP_TEMPLATE(TestE, a, b);
+NOP_EXTERNAL_TEMPLATE(TestE, a, b);
 
 template <typename T, typename U>
 struct TestF {
@@ -120,7 +120,7 @@ struct TestF {
     return a == other.a && b == other.b;
   }
 };
-NOP_TEMPLATE(TestF, a, b);
+NOP_EXTERNAL_TEMPLATE(TestF, a, b);
 
 struct TestG {
   int a;
@@ -131,20 +131,20 @@ struct TestG {
   }
 
  private:
-  NOP_MEMBERS(TestG, a, b);
+  NOP_STRUCTURE(TestG, a, b);
 };
 
 struct TestH {
   char data[128];
   unsigned char size;
 };
-NOP_STRUCTURE(TestH, (data, size));
+NOP_EXTERNAL_STRUCTURE(TestH, (data, size));
 
 struct TestH2 {
   std::array<char, 128> data;
   unsigned char size;
 };
-NOP_STRUCTURE(TestH2, (data, size));
+NOP_EXTERNAL_STRUCTURE(TestH2, (data, size));
 
 struct TestI {
   std::string names[5];
@@ -160,7 +160,7 @@ struct TestI {
     return true;
   }
 
-  NOP_MEMBERS(TestI, (names, size));
+  NOP_STRUCTURE(TestI, (names, size));
 };
 
 }  // anonymous namespace