Clean-ups to logging and type signatures

[invirt/third/libt4.git] / rpc / marshall.h

diff --git a/rpc/marshall.h b/rpc/marshall.h
index 0e0af8d..69b10df 100644 (file)
--- a/rpc/marshall.h
+++ b/rpc/marshall.h
@@ -32,7 +32,7 @@ class marshall {
         // with header
         inline operator string() const { return buf_.substr(0,index_); }
         // without header
         // with header
         inline operator string() const { return buf_.substr(0,index_); }
         // without header

-        inline string content() { return buf_.substr(RPC_HEADER_SZ,index_-RPC_HEADER_SZ); }
+        inline string content() const { return buf_.substr(RPC_HEADER_SZ,index_-RPC_HEADER_SZ); }

 
         // letting S be a defaulted template parameter forces the compiler to
         // delay looking up operator<<(marshall&, rpc_sz_t) until we define it
 
         // letting S be a defaulted template parameter forces the compiler to
         // delay looking up operator<<(marshall&, rpc_sz_t) until we define it

@@ -54,7 +54,6 @@ class unmarshall {
         bool ok_ = false;
 
     public:
         bool ok_ = false;
 
     public:

-        unmarshall() {}

         unmarshall(const string &s, bool has_header)
             : buf_(s),index_(RPC_HEADER_SZ) {
             if (!has_header)
         unmarshall(const string &s, bool has_header)
             : buf_(s),index_(RPC_HEADER_SZ) {
             if (!has_header)

@@ -73,7 +72,7 @@ class unmarshall {
             index_ += n;
         }
 
             index_ += n;
         }
 

-        template <class T> void
+        template <class T> inline void

         unpack_header(T & h) {
             VERIFY(sizeof(T)+sizeof(rpc_sz_t) <= RPC_HEADER_SZ);
             // first 4 bytes hold length field
         unpack_header(T & h) {
             VERIFY(sizeof(T)+sizeof(rpc_sz_t) <= RPC_HEADER_SZ);
             // first 4 bytes hold length field

@@ -82,7 +81,7 @@ class unmarshall {
             index_ = RPC_HEADER_SZ;
         }
 
             index_ = RPC_HEADER_SZ;
         }
 

-        template <class T> inline T grab() { T t; *this >> t; return t; }
+        template <class T> inline T _grab() { T t; *this >> t; return t; }

 };
 
 //
 };
 
 //

@@ -176,10 +175,10 @@ operator<<(marshall &m, const A &x) {
 template <class A> inline typename
 enable_if<supports_emplace_back<A>::value, unmarshall>::type &
 operator>>(unmarshall &u, A &x) {
 template <class A> inline typename
 enable_if<supports_emplace_back<A>::value, unmarshall>::type &
 operator>>(unmarshall &u, A &x) {

-    unsigned n = u.grab<unsigned>();
+    unsigned n = u._grab<unsigned>();

     x.clear();
     while (n--)
     x.clear();
     while (n--)

-        x.emplace_back(u.grab<typename A::value_type>());
+        x.emplace_back(u._grab<typename A::value_type>());

     return u;
 }
 
     return u;
 }
 

@@ -197,10 +196,10 @@ operator>>(unmarshall &u, pair<A,B> &d) {
 // std::map<A, B>
 template <class A, class B> inline unmarshall &
 operator>>(unmarshall &u, map<A,B> &x) {
 // std::map<A, B>
 template <class A, class B> inline unmarshall &
 operator>>(unmarshall &u, map<A,B> &x) {

-    unsigned n = u.grab<unsigned>();
+    unsigned n = u._grab<unsigned>();

     x.clear();
     while (n--)
     x.clear();
     while (n--)

-        x.emplace(u.grab<pair<A,B>>());
+        x.emplace(u._grab<pair<A,B>>());

     return u;
 }
 
     return u;
 }
 

@@ -212,7 +211,7 @@ inline marshall & operator<<(marshall &m, const string &s) {
 }
 
 inline unmarshall & operator>>(unmarshall &u, string &s) {
 }
 
 inline unmarshall & operator>>(unmarshall &u, string &s) {

-    uint32_t sz = u.grab<uint32_t>();
+    uint32_t sz = u._grab<uint32_t>();

     if (u.ok()) {
         s.resize(sz);
         u.rawbytes(&s[0], sz);
     if (u.ok()) {
         s.resize(sz);
         u.rawbytes(&s[0], sz);

@@ -231,7 +230,20 @@ operator<<(marshall &m, E e) {
 
 template <class E> typename enable_if<is_enum<E>::value, unmarshall>::type &
 operator>>(unmarshall &u, E &e) {
 
 template <class E> typename enable_if<is_enum<E>::value, unmarshall>::type &
 operator>>(unmarshall &u, E &e) {

-    e = to_enum<E>(u.grab<enum_type_t<E>>());
+    e = to_enum<E>(u._grab<enum_type_t<E>>());
+    return u;
+}
+
+//
+// Recursive marshalling
+//
+
+inline marshall & operator<<(marshall &m, marshall &n) {
+    return m << n.content();
+}
+
+inline unmarshall & operator>>(unmarshall &u, unmarshall &v) {
+    v = unmarshall(u._grab<string>(), false);

     return u;
 }
 
     return u;
 }