X-Git-Url: http://xvm.mit.edu/gitweb/invirt/third/libt4.git/blobdiff_plain/2546a41ad36fdc9ef6471cb35a1d56930ae1b527..5a5c578e2e358a121cdb9234a6cb11c4ecfbf323:/rpc/marshall.h

diff --git a/rpc/marshall.h b/rpc/marshall.h
index abeaae7..20b9c07 100644
--- a/rpc/marshall.h
+++ b/rpc/marshall.h
@@ -1,16 +1,10 @@
 #ifndef marshall_h
 #define marshall_h
 
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <vector>
-#include <map>
-#include <stdlib.h>
-#include <string.h>
+#include "types.h"
+#include <cstring>
 #include <cstddef>
-#include <inttypes.h>
-#include "lang/verify.h"
+#include <cinttypes>
 
 using proc_t = uint32_t;
 using status_t = int32_t;
@@ -56,7 +50,7 @@ typedef int rpc_sz_t;
 
 //size of initial buffer allocation
 #define DEFAULT_RPC_SZ 1024
-#define RPC_HEADER_SZ (std::max(sizeof(request_header), sizeof(reply_header)) + sizeof(rpc_sz_t))
+#define RPC_HEADER_SZ (max(sizeof(request_header), sizeof(reply_header)) + sizeof(rpc_sz_t))
 
 class marshall {
     private:
@@ -66,7 +60,7 @@ class marshall {
 
         inline void reserve(size_t n) {
             if((index_+n) > capacity_){
-                capacity_ += std::max(capacity_, n);
+                capacity_ += max(capacity_, n);
                 VERIFY (buf_ != NULL);
                 buf_ = (char *)realloc(buf_, capacity_);
                 VERIFY(buf_);
@@ -106,12 +100,12 @@ class marshall {
         }
 
         // Return the current content (excluding header) as a string
-        std::string get_content() {
-            return std::string(buf_+RPC_HEADER_SZ,index_-RPC_HEADER_SZ);
+        string get_content() {
+            return string(buf_+RPC_HEADER_SZ,index_-RPC_HEADER_SZ);
         }
 
         // Return the current content (excluding header) as a string
-        std::string str() {
+        string str() {
             return get_content();
         }
 
@@ -135,16 +129,9 @@ marshall& operator<<(marshall &, int8_t);
 marshall& operator<<(marshall &, uint16_t);
 marshall& operator<<(marshall &, int16_t);
 marshall& operator<<(marshall &, uint64_t);
-marshall& operator<<(marshall &, const std::string &);
+marshall& operator<<(marshall &, const string &);
 
-template <class A, typename I=void>
-struct is_enumerable : std::false_type {};
-
-template<class A> struct is_enumerable<A,
-    decltype(std::declval<A&>().cbegin(), std::declval<A&>().cend(), void())
-> : std::true_type {};
-
-template <class A> typename std::enable_if<is_enumerable<A>::value, marshall>::type &
+template <class A> typename enable_if<is_iterable<A>::value, marshall>::type &
 operator<<(marshall &m, const A &x) {
     m << (unsigned int) x.size();
     for (const auto &a : x)
@@ -153,16 +140,16 @@ operator<<(marshall &m, const A &x) {
 }
 
 template <class A, class B> marshall &
-operator<<(marshall &m, const std::pair<A,B> &d) {
+operator<<(marshall &m, const pair<A,B> &d) {
     return m << d.first << d.second;
 }
 
 template<typename E>
-using enum_type_t = typename std::enable_if<std::is_enum<E>::value, typename std::underlying_type<E>::type>::type;
+using enum_type_t = typename enable_if<is_enum<E>::value, typename underlying_type<E>::type>::type;
 template<typename E> constexpr inline enum_type_t<E> from_enum(E e) noexcept { return (enum_type_t<E>)e; }
 template<typename E> constexpr inline E to_enum(enum_type_t<E> value) noexcept { return (E)value; }
 
-template <class E> typename std::enable_if<std::is_enum<E>::value, marshall>::type &
+template <class E> typename enable_if<is_enum<E>::value, marshall>::type &
 operator<<(marshall &m, E e) {
     return m << from_enum(e);
 }
@@ -179,8 +166,8 @@ unmarshall& operator>>(unmarshall &, int32_t &);
 unmarshall& operator>>(unmarshall &, size_t &);
 unmarshall& operator>>(unmarshall &, uint64_t &);
 unmarshall& operator>>(unmarshall &, int64_t &);
-unmarshall& operator>>(unmarshall &, std::string &);
-template <class E> typename std::enable_if<std::is_enum<E>::value, unmarshall>::type &
+unmarshall& operator>>(unmarshall &, string &);
+template <class E> typename enable_if<is_enum<E>::value, unmarshall>::type &
 operator>>(unmarshall &u, E &e);
 
 class unmarshall {
@@ -194,7 +181,7 @@ class unmarshall {
     public:
         unmarshall(): buf_(NULL),sz_(0),index_(0),ok_(false) {}
         unmarshall(char *b, size_t sz): buf_(b),sz_(sz),index_(),ok_(true) {}
-        unmarshall(const std::string &s) : buf_(NULL),sz_(0),index_(0),ok_(false)
+        unmarshall(const string &s) : buf_(NULL),sz_(0),index_(0),ok_(false)
         {
             //take the content which does not exclude a RPC header from a string
             take_content(s);
@@ -207,7 +194,7 @@ class unmarshall {
         void take_in(unmarshall &another);
 
         //take the content which does not exclude a RPC header from a string
-        void take_content(const std::string &s) {
+        void take_content(const string &s) {
             sz_ = s.size()+RPC_HEADER_SZ;
             buf_ = (char *)realloc(buf_,sz_);
             VERIFY(buf_);
@@ -221,7 +208,7 @@ class unmarshall {
         bool okdone() const { return ok_ && index_ == sz_; }
 
         uint8_t rawbyte();
-        void rawbytes(std::string &s, size_t n);
+        void rawbytes(string &s, size_t n);
         template <class T> void rawbytes(T &t);
 
         size_t ind() { return index_;}
@@ -255,7 +242,7 @@ class unmarshall {
         }
 };
 
-template <class A> typename std::enable_if<is_enumerable<A>::value, unmarshall>::type &
+template <class A> typename enable_if<is_iterable<A>::value, unmarshall>::type &
 operator>>(unmarshall &u, A &x) {
     unsigned n = u.grab<unsigned>();
     x.clear();
@@ -265,26 +252,26 @@ operator>>(unmarshall &u, A &x) {
 }
 
 template <class A, class B> unmarshall &
-operator>>(unmarshall &u, std::map<A,B> &x) {
+operator>>(unmarshall &u, map<A,B> &x) {
     unsigned n = u.grab<unsigned>();
     x.clear();
     while (n--)
-        x.emplace(u.grab<std::pair<A,B>>());
+        x.emplace(u.grab<pair<A,B>>());
     return u;
 }
 
 template <class A, class B> unmarshall &
-operator>>(unmarshall &u, std::pair<A,B> &d) {
+operator>>(unmarshall &u, pair<A,B> &d) {
     return u >> d.first >> d.second;
 }
 
-template <class E> typename std::enable_if<std::is_enum<E>::value, unmarshall>::type &
+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>>());
     return u;
 }
 
-typedef std::function<int(unmarshall &, marshall &)> handler;
+typedef function<int(unmarshall &, marshall &)> handler;
 
 //
 // Automatic marshalling wrappers for RPC handlers
@@ -294,7 +281,7 @@ typedef std::function<int(unmarshall &, marshall &)> handler;
 // C++11 does neither of these two things for us:
 // 1) Declare variables using a parameter pack expansion, like so
 //      Args ...args;
-// 2) Call a function with a std::tuple of the arguments it expects
+// 2) Call a function with a tuple of the arguments it expects
 //
 // We implement an 'invoke' function for functions of the RPC handler
 // signature, i.e. int(R & r, const Args...)
@@ -339,17 +326,17 @@ struct VerifyOnFailure {
 // One for function pointers...
 
 template <class F, class R, class RV, class args_type, size_t ...Indices>
-typename std::enable_if<!std::is_member_function_pointer<F>::value, RV>::type
+typename enable_if<!is_member_function_pointer<F>::value, RV>::type
 invoke(RV, F f, void *, R & r, args_type & t, tuple_indices<Indices...>) {
-    return f(r, std::move(std::get<Indices>(t))...);
+    return f(r, move(get<Indices>(t))...);
 }
 
 // And one for pointers to member functions...
 
 template <class F, class C, class RV, class R, class args_type, size_t ...Indices>
-typename std::enable_if<std::is_member_function_pointer<F>::value, RV>::type
+typename enable_if<is_member_function_pointer<F>::value, RV>::type
 invoke(RV, F f, C *c, R & r, args_type & t, tuple_indices<Indices...>) {
-    return (c->*f)(r, std::move(std::get<Indices>(t))...);
+    return (c->*f)(r, move(get<Indices>(t))...);
 }
 
 // The class marshalled_func_imp uses partial template specialization to
@@ -373,15 +360,15 @@ struct marshalled_func_imp<F, C, RV(R&, Args...), ErrorHandler> {
         // template parameters running from 0 up to (# args) - 1.
         using Indices = typename make_tuple_indices<sizeof...(Args)>::type;
         // This type definition represents storage for f's unmarshalled
-        // arguments.  std::decay is (most notably) stripping off const
+        // arguments.  decay is (most notably) stripping off const
         // qualifiers.
-        using ArgsStorage = std::tuple<typename std::decay<Args>::type...>;
-        // Allocate a handler (i.e. std::function) to hold the lambda
+        using ArgsStorage = tuple<typename decay<Args>::type...>;
+        // Allocate a handler (i.e. function) to hold the lambda
         // which will unmarshall RPCs and call f.
         return new handler([=](unmarshall &u, marshall &m) -> RV {
             // Unmarshall each argument with the correct type and store the
             // result in a tuple.
-            ArgsStorage t = {u.grab<typename std::decay<Args>::type>()...};
+            ArgsStorage t = {u.grab<typename decay<Args>::type>()...};
             // Verify successful unmarshalling of the entire input stream.
             if (!u.okdone())
                 return (RV)ErrorHandler::unmarshall_args_failure();
@@ -417,7 +404,7 @@ struct marshalled_func<F, ErrorHandler, RV(C::*)(Args...)> :
     public marshalled_func_imp<F, C, RV(Args...), ErrorHandler> {};
 
 template <class F, class ErrorHandler, class Signature>
-struct marshalled_func<F, ErrorHandler, std::function<Signature>> :
+struct marshalled_func<F, ErrorHandler, function<Signature>> :
     public marshalled_func_imp<F, void, Signature, ErrorHandler> {};
 
 #endif