hobbes
a language, embedded compiler, and runtime for efficient dynamic expression evaluation, data storage and analysis
Classes | Namespaces | Macros | Typedefs | Functions
net.H File Reference
#include <vector>
#include <queue>
#include <functional>
#include <string>
#include <sstream>
#include <tuple>
#include <map>
#include <stdexcept>
#include <sys/types.h>
#include <sys/un.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
Include dependency graph for net.H:

Go to the source code of this file.

Classes

struct  hobbes::net::RPCDef
 
struct  hobbes::net::io< T, P >
 
struct  hobbes::net::cannot_memcpy< T, P >
 
struct  hobbes::net::cannot_memcpy< T, typename io< T >::can_memcpy >
 
struct  hobbes::net::unit
 
struct  hobbes::net::io< unit >
 
struct  hobbes::net::io< T, typename T::is_hnet_enum >
 
struct  hobbes::net::io< T, typename T::is_hnet_variant >
 
struct  hobbes::net::io< std::pair< U, V > >
 
struct  hobbes::net::io< std::pair< U, V > >::async_read_state
 
struct  hobbes::net::io< std::vector< T >, typename io< T >::can_memcpy >
 
struct  hobbes::net::io< std::vector< T >, typename io< T >::can_memcpy >::async_read_state
 
struct  hobbes::net::io< std::vector< T >, typename cannot_memcpy< T >::type >
 
struct  hobbes::net::io< std::vector< T >, typename cannot_memcpy< T >::type >::async_read_state
 
struct  hobbes::net::io< std::map< K, T > >
 
struct  hobbes::net::io< std::map< K, T > >::async_read_state
 
struct  hobbes::net::io< const char * >
 
struct  hobbes::net::io< std::string >
 
struct  hobbes::net::io< std::string >::async_read_state
 
struct  hobbes::net::io< T, typename T::is_hnet_struct >
 
struct  hobbes::net::oSeq< Ts >
 
struct  hobbes::net::oSeq< T, Ts... >
 
struct  hobbes::net::ioTuple< i, e, Ts >
 
struct  hobbes::net::ioTuple< e, e, Ts... >
 
struct  hobbes::net::aioTupleState< Ts >
 
struct  hobbes::net::aioTupleState< T, Ts... >
 
struct  hobbes::net::aioTupleStateAt< i, T >
 
struct  hobbes::net::aioTupleStateAt< 0, std::pair< U, V > >
 
struct  hobbes::net::aioTupleStateAt< i, std::pair< U, V > >
 
struct  hobbes::net::aioTupleRead< i, e, Ts >
 
struct  hobbes::net::aioTupleRead< e, e, Ts... >
 
struct  hobbes::net::io< std::tuple< Ts... > >
 
struct  hobbes::net::io< T, typename T::is_hnet_alias >
 
struct  hobbes::net::RPCTyDef< F >
 
struct  hobbes::net::RPCTyDef< R(Args...)>
 
struct  hobbes::net::RPCTyDef< void(Args...)>
 
struct  hobbes::net::RPCFunc< F >
 
struct  hobbes::net::RPCFunc< R(Args...)>
 
struct  hobbes::net::RPCFunc< void(Args...)>
 
struct  hobbes::net::AsyncReader
 
struct  hobbes::net::AsyncScheduler
 
struct  hobbes::net::AsyncRPCFunc< F >
 
struct  hobbes::net::AsyncRPCFunc< R(Args...)>
 
struct  hobbes::net::AsyncRPCFunc< void(Args...)>
 

Namespaces

 hobbes
 
 hobbes::net
 

Macros

#define HNET_VERSION   ((uint32_t)0x00010000)
 
#define HNET_CMD_DEFEXPR   ((uint8_t)0)
 
#define HNET_CMD_INVOKE   ((uint8_t)2)
 
#define HNET_RESULT_FAIL   0
 
#define _HNET_FIRST(a, ...)   a
 
#define _HNET_SECOND(a, b, ...)   b
 
#define _HNET_JOIN(a, b)   a ## b
 
#define _HNET_IS_NEGATE(...)   _HNET_SECOND(__VA_ARGS__, 0)
 
#define _HNET_NOT(x)   _HNET_IS_NEGATE(_HNET_JOIN(_HNET__NOT_, x))
 
#define _HNET__NOT_0   NEGATE, 1
 
#define _HNET_BOOL(x)   _HNET_NOT(_HNET_NOT(x))
 
#define _HNET_IF_ELSE(condition)   _HNET__IF_ELSE(_HNET_BOOL(condition))
 
#define _HNET__IF_ELSE(condition)   _HNET_JOIN(_HNET__IF_, condition)
 
#define _HNET__IF_1(...)   __VA_ARGS__ _HNET__IF_1_ELSE
 
#define _HNET__IF_0(...)   _HNET__IF_0_ELSE
 
#define _HNET__IF_1_ELSE(...)
 
#define _HNET__IF_0_ELSE(...)   __VA_ARGS__
 
#define _HNET_EMPTY()
 
#define _HNET_EVAL(...)   _HNET_EVAL256(__VA_ARGS__)
 
#define _HNET_EVAL256(...)   _HNET_EVAL128(_HNET_EVAL128(__VA_ARGS__))
 
#define _HNET_EVAL128(...)   _HNET_EVAL64(_HNET_EVAL64(__VA_ARGS__))
 
#define _HNET_EVAL64(...)   _HNET_EVAL32(_HNET_EVAL32(__VA_ARGS__))
 
#define _HNET_EVAL32(...)   _HNET_EVAL16(_HNET_EVAL16(__VA_ARGS__))
 
#define _HNET_EVAL16(...)   _HNET_EVAL8(_HNET_EVAL8(__VA_ARGS__))
 
#define _HNET_EVAL8(...)   _HNET_EVAL4(_HNET_EVAL4(__VA_ARGS__))
 
#define _HNET_EVAL4(...)   _HNET_EVAL2(_HNET_EVAL2(__VA_ARGS__))
 
#define _HNET_EVAL2(...)   _HNET_EVAL1(_HNET_EVAL1(__VA_ARGS__))
 
#define _HNET_EVAL1(...)   __VA_ARGS__
 
#define _HNET_DEFER2(m)   m _HNET_EMPTY _HNET_EMPTY()()
 
#define _HNET_HAS_PARGS(...)   _HNET_BOOL(_HNET_FIRST(_HNET__EOAP_ __VA_ARGS__)())
 
#define _HNET__EOAP_(...)   _HNET_BOOL(_HNET_FIRST(_HNET__EOA_ __VA_ARGS__)())
 
#define _HNET__EOA_()   0
 
#define _HNET_MAP(f, VS...)   _HNET_EVAL(_HNET_MAPP(f, VS))
 
#define _HNET_MAPP(f, H, T...)
 
#define _HNET__MAPP()   _HNET_MAPP
 
#define _HNET_TYCTOR_PRIM   ((int)0)
 
#define _HNET_TYCTOR_TVAR   ((int)2)
 
#define _HNET_TYCTOR_FIXEDARR   ((int)4)
 
#define _HNET_TYCTOR_ARR   ((int)5)
 
#define _HNET_TYCTOR_VARIANT   ((int)6)
 
#define _HNET_TYCTOR_STRUCT   ((int)7)
 
#define _HNET_TYCTOR_SIZE   ((int)11)
 
#define _HNET_TYCTOR_RECURSIVE   ((int)13)
 
#define _HNET_DEFINE_PRIMTYS(T, n)
 
#define HNET_ENUM_CTOR_DEF(n)   n ,
 
#define HNET_ENUM_CTOR_CTOR(n)   static const SelfT n() { return SelfT(SelfT::Enum::n); }
 
#define HNET_ENUM_CTORC_SUCC(n)   +1
 
#define HNET_ENUM_CTOR_STR(n)   + "|" #n
 
#define HNET_ENUM_CTOR_ENCODE(n)
 
#define HNET_ENUM_TOSTR_CASE(n)   case SelfT :: Enum :: n: o << "|" #n "|"; break;
 
#define DEFINE_HNET_ENUM(T, CTORS...)
 
#define DEFINE_HNET_VARIANT_GEN(T, VDECL, VCTORS, VCOPY, VDESTROY, CTORCOUNT, VENCODE, VDESC, VWRITE, VREAD, VVISITCASE, VEQCASE, CTAGS, CDATA, CAIOSTATES, CAIOSTATEINIT, CAIOREAD)
 
#define HNET_VARIANT_CTOR(n, t)   static SelfT n(const t & x) { SelfT r; r.tag = Enum::tag_##n; new (r.data) t(x); return r; }
 
#define HNET_VARIANT_CTOR_STR(n, t)   + "," #n ":" + ::hobbes::net::io< t >::describe()
 
#define HNET_VARIANT_CTOR_TAG(n, t)   tag_##n,
 
#define HNET_VARIANT_WRITE_CASE(n, t)   case Enum::tag_##n: ::hobbes::net::io<int>::write(s, (int)this->tag); ::hobbes::net::io< t >::write(s, this->n##_data); break;
 
#define HNET_VARIANT_READ_CASE(n, t)   case Enum::tag_##n: new (this->data) t(); ::hobbes::net::io< t >::read(s, &this->n##_data); break;
 
#define HNET_VARIANT_PCOPY(n, t)   case Enum::tag_##n: new (this->data) t(rhs.n##_data); break;
 
#define HNET_VARIANT_PDESTROY(n, t)   case Enum::tag_##n: { typedef t __DT; ((__DT*)&this->n##_data)->~__DT(); } break;
 
#define HNET_VARIANT_SUCC(n, t)   +1
 
#define HNET_VARIANT_CTOR_OPAQUEDATA(n, t)   t n##_data;
 
#define HNET_VARIANT_CTOR_ENCODE(n, t)
 
#define HNET_VARIANT_VDECL(n, t)   virtual R n(const t & x) const = 0;
 
#define HNET_VARIANT_VCASE(n, t)   case Enum::tag_##n: return v.n (this->n##_data);
 
#define HNET_VARIANT_EQCASE(n, t)   case Enum::tag_##n: return (this->n##_data == rhs.n##_data);
 
#define HNET_VARIANT_AIOSTATE_DATA(n, t)   ::hobbes::net::io<t>::async_read_state n##_aioS;
 
#define HNET_VARIANT_AIOSTATE_INIT(n, t)   case Enum::tag_##n: { new (o->payloadS.data) ::hobbes::net::io<t>::async_read_state(); ::hobbes::net::io<t>::prepare(&o->payloadS.n##_aioS); new (x->data) t(); } break;
 
#define HNET_VARIANT_AIOSTATE_ACCUM(n, t)   case Enum::tag_##n: return ::hobbes::net::io<t>::accum(s, &o->payloadS.n##_aioS, &x->n##_data);
 
#define DEFINE_HNET_VARIANT(T, CTORS...)   DEFINE_HNET_VARIANT_GEN(T, _HNET_MAP(HNET_VARIANT_VDECL, CTORS), _HNET_MAP(HNET_VARIANT_CTOR, CTORS), _HNET_MAP(HNET_VARIANT_PCOPY, CTORS), _HNET_MAP(HNET_VARIANT_PDESTROY, CTORS), _HNET_MAP(HNET_VARIANT_SUCC, CTORS), _HNET_MAP(HNET_VARIANT_CTOR_ENCODE, CTORS), _HNET_MAP(HNET_VARIANT_CTOR_STR, CTORS), _HNET_MAP(HNET_VARIANT_WRITE_CASE, CTORS), _HNET_MAP(HNET_VARIANT_READ_CASE, CTORS), _HNET_MAP(HNET_VARIANT_VCASE, CTORS), _HNET_MAP(HNET_VARIANT_EQCASE, CTORS), _HNET_MAP(HNET_VARIANT_CTOR_TAG, CTORS), _HNET_MAP(HNET_VARIANT_CTOR_OPAQUEDATA, CTORS), _HNET_MAP(HNET_VARIANT_AIOSTATE_DATA, CTORS), _HNET_MAP(HNET_VARIANT_AIOSTATE_INIT, CTORS), _HNET_MAP(HNET_VARIANT_AIOSTATE_ACCUM, CTORS))
 
#define HNET_VARIANT_LBL_CTOR(n, lbl, t)   static SelfT n(const t & x) { SelfT r; r.tag = Enum::tag_##n; new (r.data) t(x); return r; }
 
#define HNET_VARIANT_LBL_CTOR_STR(n, lbl, t)   + "," #n ":" + ::hobbes::net::io< t >::describe()
 
#define HNET_VARIANT_LBL_CTOR_TAG(n, lbl, t)   tag_##n,
 
#define HNET_VARIANT_LBL_WRITE_CASE(n, lbl, t)   case Enum::tag_##n: ::hobbes::net::io<int>::write(s, (int)this->tag); ::hobbes::net::io< t >::write(s, this->n##_data); break;
 
#define HNET_VARIANT_LBL_READ_CASE(n, lbl, t)   case Enum::tag_##n: new (this->data) t(); ::hobbes::net::io< t >::read(s, &this->n##_data); break;
 
#define HNET_VARIANT_LBL_PCOPY(n, lbl, t)   case Enum::tag_##n: new (this->data) t(rhs.n##_data); break;
 
#define HNET_VARIANT_LBL_PDESTROY(n, lbl, t)   case Enum::tag_##n: { typedef t __DT; ((__DT*)&this->n##_data)->~__DT(); } break;
 
#define HNET_VARIANT_LBL_SUCC(n, lbl, t)   +1
 
#define HNET_VARIANT_LBL_CTOR_OPAQUEDATA(n, lbl, t)   t n##_data;
 
#define HNET_VARIANT_LBL_CTOR_ENCODE(n, lbl, t)
 
#define HNET_VARIANT_LBL_VDECL(n, lbl, t)   virtual R n(const t & x) const = 0;
 
#define HNET_VARIANT_LBL_VCASE(n, lbl, t)   case Enum::tag_##n: return v. n (this->n##_data);
 
#define HNET_VARIANT_LBL_EQCASE(n, lbl, t)   case Enum::tag_##n: return (this->n##_data == rhs.n##_data);
 
#define HNET_VARIANT_LBL_CTOR_AIOSTATE_DATA(n, lbl, t)   ::hobbes::net::io<t>::async_read_state n##_aioS;
 
#define HNET_VARIANT_LBL_CTOR_AIOSTATE_INIT(n, lbl, t)   case Enum::tag_##n: { new (o->payloadS.data) ::hobbes::net::io<t>::async_read_state(); ::hobbes::net::io<t>::prepare(&o->payloadS.n##_aioS); new (x->data) t(); } break;
 
#define HNET_VARIANT_LBL_CTOR_AIOSTATE_ACCUM(n, lbl, t)   case Enum::tag_##n: return ::hobbes::net::io<t>::accum(s, &o->payloadS.n##_aioS, &x->n##_data);
 
#define DEFINE_HNET_VARIANT_WITH_LABELS(T, CTORS...)   DEFINE_HNET_VARIANT_GEN(T, _HNET_MAP(HNET_VARIANT_LBL_VDECL, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR, CTORS), _HNET_MAP(HNET_VARIANT_LBL_PCOPY, CTORS), _HNET_MAP(HNET_VARIANT_LBL_PDESTROY, CTORS), _HNET_MAP(HNET_VARIANT_LBL_SUCC, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_ENCODE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_STR, CTORS), _HNET_MAP(HNET_VARIANT_LBL_WRITE_CASE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_READ_CASE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_VCASE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_EQCASE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_TAG, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_OPAQUEDATA, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_AIOSTATE_DATA, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_AIOSTATE_INIT, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_AIOSTATE_ACCUM, CTORS))
 
#define HNET_FIELDC_SUCC(t, n)   +1
 
#define HNET_FIELD_COUNT(FIELDS...)   (0 _HNET_MAP(HNET_FIELDC_SUCC, FIELDS))
 
#define HNET_FIELDW_SUCC(t, n)   ::hobbes::net::io< t >::write(s, this-> n);
 
#define HNET_FIELD_WRITES(FIELDS...)   _HNET_MAP(HNET_FIELDW_SUCC, FIELDS)
 
#define HNET_FIELDR_SUCC(t, n)   ::hobbes::net::io< t >::read(s, &this-> n);
 
#define HNET_FIELD_READS(FIELDS...)   _HNET_MAP(HNET_FIELDR_SUCC, FIELDS)
 
#define HNET_STRUCT_FIELD(t, n)   t n;
 
#define HNET_STRUCT_FIELD_ENC(t, n)   ::hobbes::net::ws(#n, out); ::hobbes::net::w((int)-1, out); ::hobbes::net::io< t >::encode(out);
 
#define HNET_STRUCT_FIELD_DESC(t, n)   + (", " #n " : " + ::hobbes::net::io< t >::describe())
 
#define HNET_FIELD_ASYNC_READ_IDX_DEF(_, n)   readAt_##n,
 
#define HNET_FIELD_ASYNC_READ_STATE_DEC(t, n)   ::hobbes::net::io< t >::async_read_state n;
 
#define HNET_FIELD_ASYNC_READ_STATE_INIT(t, n)   ::hobbes::net::io< t >::prepare(&o->fieldStates.n);
 
#define HNET_FIELD_ASYNC_READ_FIELD(t, n)   case FieldIndex::readAt_##n: if (::hobbes::net::io< t >::accum(s, &o->fieldStates.n, &x->n)) { o->idx = (FieldIndex)(((uint32_t)o->idx) + 1); } break;
 
#define DEFINE_HNET_STRUCT(T, FIELDS...)
 
#define DEFINE_HNET_TYPE_ALIAS(_ATY, _REPTY)
 
#define _HNET_CLIENT_MAKE_EXPRID(n, _, __)   , exprID_##n
 
#define _HNET_CLIENT_MAKE_RPCDEF(n, t, e)   result.push_back(::hobbes::net::RPCDef((uint32_t)exprID_##n, e, ::hobbes::net::RPCTyDef<t>::inputType(), ::hobbes::net::RPCTyDef<t>::outputType()));
 
#define _HNET_CLIENT_INIT_RPCFUNC(n, t, _)   , n(&this->s, (uint32_t)exprID_##n)
 
#define _HNET_CLIENT_MAKE_RPCFUNC(n, t, _)   ::hobbes::net::RPCFunc<t> n;
 
#define DEFINE_NET_CLIENT(T, C...)
 
#define _HNET_CLIENT_INIT_ASYNC_RPCFUNC(n, t, _)   , n(this, &this->s, (uint32_t)exprID_##n)
 
#define _HNET_CLIENT_MAKE_ASYNC_RPCFUNC(n, t, _)   ::hobbes::net::AsyncRPCFunc<t> n;
 
#define DEFINE_ASYNC_NET_CLIENT(T, C...)
 

Typedefs

typedef std::vector< uint8_t > hobbes::net::bytes
 
typedef std::vector< RPCDef > hobbes::net::RPCDefs
 

Functions

void hobbes::net::sendData (int socket, const uint8_t *d, size_t sz)
 
void hobbes::net::sendString (int socket, const std::string &s)
 
void hobbes::net::sendBytes (int socket, const bytes &x)
 
void hobbes::net::recvData (int socket, uint8_t *d, size_t sz)
 
void hobbes::net::recvString (int socket, std::string *x)
 
void hobbes::net::setBlockingBit (int socket, bool block)
 
size_t hobbes::net::recvDataPartial (int socket, uint8_t *d, size_t sz)
 
int hobbes::net::initSession (int s, const RPCDefs &rpcds)
 
int hobbes::net::makeConnection (int s, sockaddr *saddr, size_t len)
 
int hobbes::net::makeConnection (const hostent &host, int port)
 
int hobbes::net::makeConnection (const std::string &host, size_t port)
 
int hobbes::net::makeConnection (const std::string &host, const std::string &port)
 
int hobbes::net::makeConnection (const std::string &hostport)
 
template<typename T >
void hobbes::net::w (const T &x, bytes *out)
 
void hobbes::net::ws (const char *x, bytes *out)
 
void hobbes::net::ws (const std::string &x, bytes *out)
 
void hobbes::net::ws (const bytes &x, bytes *out)
 
void hobbes::net::encode_primty (const char *tn, bytes *out)
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (bool, "bool")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (uint8_t, "byte")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (char, "char")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (int16_t, "short")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (uint16_t, "short")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (int32_t, "int")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (uint32_t, "int")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (int64_t, "long")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (uint64_t, "long")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (float, "float")
 
 hobbes::net::_HNET_DEFINE_PRIMTYS (double, "double")
 

Macro Definition Documentation

◆ _HNET__EOA_

#define _HNET__EOA_ ( )    0

◆ _HNET__EOAP_

#define _HNET__EOAP_ (   ...)    _HNET_BOOL(_HNET_FIRST(_HNET__EOA_ __VA_ARGS__)())

◆ _HNET__IF_0

#define _HNET__IF_0 (   ...)    _HNET__IF_0_ELSE

◆ _HNET__IF_0_ELSE

#define _HNET__IF_0_ELSE (   ...)    __VA_ARGS__

◆ _HNET__IF_1

#define _HNET__IF_1 (   ...)    __VA_ARGS__ _HNET__IF_1_ELSE

◆ _HNET__IF_1_ELSE

#define _HNET__IF_1_ELSE (   ...)

◆ _HNET__IF_ELSE

#define _HNET__IF_ELSE (   condition)    _HNET_JOIN(_HNET__IF_, condition)

◆ _HNET__MAPP

#define _HNET__MAPP ( )    _HNET_MAPP

◆ _HNET__NOT_0

#define _HNET__NOT_0   NEGATE, 1

◆ _HNET_BOOL

#define _HNET_BOOL (   x)    _HNET_NOT(_HNET_NOT(x))

◆ _HNET_CLIENT_INIT_ASYNC_RPCFUNC

#define _HNET_CLIENT_INIT_ASYNC_RPCFUNC (   n,
  t,
  _ 
)    , n(this, &this->s, (uint32_t)exprID_##n)

◆ _HNET_CLIENT_INIT_RPCFUNC

#define _HNET_CLIENT_INIT_RPCFUNC (   n,
  t,
  _ 
)    , n(&this->s, (uint32_t)exprID_##n)

◆ _HNET_CLIENT_MAKE_ASYNC_RPCFUNC

#define _HNET_CLIENT_MAKE_ASYNC_RPCFUNC (   n,
  t,
  _ 
)    ::hobbes::net::AsyncRPCFunc<t> n;

◆ _HNET_CLIENT_MAKE_EXPRID

#define _HNET_CLIENT_MAKE_EXPRID (   n,
  _,
  __ 
)    , exprID_##n

◆ _HNET_CLIENT_MAKE_RPCDEF

#define _HNET_CLIENT_MAKE_RPCDEF (   n,
  t,
  e 
)    result.push_back(::hobbes::net::RPCDef((uint32_t)exprID_##n, e, ::hobbes::net::RPCTyDef<t>::inputType(), ::hobbes::net::RPCTyDef<t>::outputType()));

◆ _HNET_CLIENT_MAKE_RPCFUNC

#define _HNET_CLIENT_MAKE_RPCFUNC (   n,
  t,
  _ 
)    ::hobbes::net::RPCFunc<t> n;

◆ _HNET_DEFER2

#define _HNET_DEFER2 (   m)    m _HNET_EMPTY _HNET_EMPTY()()

◆ _HNET_DEFINE_PRIMTYS

#define _HNET_DEFINE_PRIMTYS (   T,
  n 
)
Value:
template <> \
struct io<T> { \
typedef void can_memcpy; \
static void encode(bytes* out) { encode_primty(n, out); } \
static std::string describe() { return n; } \
static void write(int s, const T& x) { sendData(s, (const uint8_t*)&x, sizeof(x)); } \
static void read(int s, T* x) { recvData(s, (uint8_t*)x, sizeof(T)); } \
typedef uint8_t async_read_state; \
static void prepare(uint8_t* o) { *o = 0; } \
static bool accum(int s, uint8_t* o, T* x) { *o += recvDataPartial(s, ((uint8_t*)x) + *o, sizeof(T) - *o); return *o == sizeof(T); } \
}
hi::write
void write(int fd, const char *s)
Definition: www.C:23
hobbes::net::recvData
void recvData(int socket, uint8_t *d, size_t sz)
Definition: net.H:70
hobbes::encode
void encode(const PrimitivePtr &, std::ostream &)
Definition: expr.C:1674
hog::read
void read(gzbuffer *in, uint8_t *b, size_t n)
Definition: batchrecv.C:86
hobbes::net::bytes
std::vector< uint8_t > bytes
Definition: net.H:41
hobbes::net::sendData
void sendData(int socket, const uint8_t *d, size_t sz)
Definition: net.H:44
hobbes::net::encode_primty
void encode_primty(const char *tn, bytes *out)
Definition: net.H:299
hobbes::net::recvDataPartial
size_t recvDataPartial(int socket, uint8_t *d, size_t sz)
Definition: net.H:101
out
#define out
Definition: netio.H:19

◆ _HNET_EMPTY

#define _HNET_EMPTY ( )

◆ _HNET_EVAL

#define _HNET_EVAL (   ...)    _HNET_EVAL256(__VA_ARGS__)

◆ _HNET_EVAL1

#define _HNET_EVAL1 (   ...)    __VA_ARGS__

◆ _HNET_EVAL128

#define _HNET_EVAL128 (   ...)    _HNET_EVAL64(_HNET_EVAL64(__VA_ARGS__))

◆ _HNET_EVAL16

#define _HNET_EVAL16 (   ...)    _HNET_EVAL8(_HNET_EVAL8(__VA_ARGS__))

◆ _HNET_EVAL2

#define _HNET_EVAL2 (   ...)    _HNET_EVAL1(_HNET_EVAL1(__VA_ARGS__))

◆ _HNET_EVAL256

#define _HNET_EVAL256 (   ...)    _HNET_EVAL128(_HNET_EVAL128(__VA_ARGS__))

◆ _HNET_EVAL32

#define _HNET_EVAL32 (   ...)    _HNET_EVAL16(_HNET_EVAL16(__VA_ARGS__))

◆ _HNET_EVAL4

#define _HNET_EVAL4 (   ...)    _HNET_EVAL2(_HNET_EVAL2(__VA_ARGS__))

◆ _HNET_EVAL64

#define _HNET_EVAL64 (   ...)    _HNET_EVAL32(_HNET_EVAL32(__VA_ARGS__))

◆ _HNET_EVAL8

#define _HNET_EVAL8 (   ...)    _HNET_EVAL4(_HNET_EVAL4(__VA_ARGS__))

◆ _HNET_FIRST

#define _HNET_FIRST (   a,
  ... 
)    a

◆ _HNET_HAS_PARGS

#define _HNET_HAS_PARGS (   ...)    _HNET_BOOL(_HNET_FIRST(_HNET__EOAP_ __VA_ARGS__)())

◆ _HNET_IF_ELSE

#define _HNET_IF_ELSE (   condition)    _HNET__IF_ELSE(_HNET_BOOL(condition))

◆ _HNET_IS_NEGATE

#define _HNET_IS_NEGATE (   ...)    _HNET_SECOND(__VA_ARGS__, 0)

◆ _HNET_JOIN

#define _HNET_JOIN (   a,
  b 
)    a ## b

◆ _HNET_MAP

#define _HNET_MAP (   f,
  VS... 
)    _HNET_EVAL(_HNET_MAPP(f, VS))

◆ _HNET_MAPP

#define _HNET_MAPP (   f,
  H,
  T... 
)
Value:
f H \
_HNET_IF_ELSE(_HNET_HAS_PARGS(T))( \
_HNET_DEFER2(_HNET__MAPP)()(f, T) \
)( \
)
_HNET_IF_ELSE
#define _HNET_IF_ELSE(condition)
Definition: net.H:234
_HNET__MAPP
#define _HNET__MAPP()
Definition: net.H:262
_HNET_HAS_PARGS
#define _HNET_HAS_PARGS(...)
Definition: net.H:252

◆ _HNET_NOT

#define _HNET_NOT (   x)    _HNET_IS_NEGATE(_HNET_JOIN(_HNET__NOT_, x))

◆ _HNET_SECOND

#define _HNET_SECOND (   a,
  b,
  ... 
)    b

◆ _HNET_TYCTOR_ARR

#define _HNET_TYCTOR_ARR   ((int)5)

◆ _HNET_TYCTOR_FIXEDARR

#define _HNET_TYCTOR_FIXEDARR   ((int)4)

◆ _HNET_TYCTOR_PRIM

#define _HNET_TYCTOR_PRIM   ((int)0)

◆ _HNET_TYCTOR_RECURSIVE

#define _HNET_TYCTOR_RECURSIVE   ((int)13)

◆ _HNET_TYCTOR_SIZE

#define _HNET_TYCTOR_SIZE   ((int)11)

◆ _HNET_TYCTOR_STRUCT

#define _HNET_TYCTOR_STRUCT   ((int)7)

◆ _HNET_TYCTOR_TVAR

#define _HNET_TYCTOR_TVAR   ((int)2)

◆ _HNET_TYCTOR_VARIANT

#define _HNET_TYCTOR_VARIANT   ((int)6)

◆ DEFINE_ASYNC_NET_CLIENT

#define DEFINE_ASYNC_NET_CLIENT (   T,
  C... 
)

◆ DEFINE_HNET_ENUM

#define DEFINE_HNET_ENUM (   T,
  CTORS... 
)

◆ DEFINE_HNET_STRUCT

#define DEFINE_HNET_STRUCT (   T,
  FIELDS... 
)

◆ DEFINE_HNET_TYPE_ALIAS

#define DEFINE_HNET_TYPE_ALIAS (   _ATY,
  _REPTY 
)
Value:
struct _ATY { \
typedef void is_hnet_alias; \
typedef _REPTY type; \
static const char* name() { return #_ATY; } \
inline operator _REPTY() { return this->value; } \
_REPTY value; \
_ATY() : value() { } \
_ATY(const _REPTY& x) : value(x) { } \
_ATY(const _ATY& x) : value(x.value) { } \
_ATY& operator=(const _ATY& x) { this->value = x.value; return *this; } \
}

◆ DEFINE_HNET_VARIANT

#define DEFINE_HNET_VARIANT (   T,
  CTORS... 
)    DEFINE_HNET_VARIANT_GEN(T, _HNET_MAP(HNET_VARIANT_VDECL, CTORS), _HNET_MAP(HNET_VARIANT_CTOR, CTORS), _HNET_MAP(HNET_VARIANT_PCOPY, CTORS), _HNET_MAP(HNET_VARIANT_PDESTROY, CTORS), _HNET_MAP(HNET_VARIANT_SUCC, CTORS), _HNET_MAP(HNET_VARIANT_CTOR_ENCODE, CTORS), _HNET_MAP(HNET_VARIANT_CTOR_STR, CTORS), _HNET_MAP(HNET_VARIANT_WRITE_CASE, CTORS), _HNET_MAP(HNET_VARIANT_READ_CASE, CTORS), _HNET_MAP(HNET_VARIANT_VCASE, CTORS), _HNET_MAP(HNET_VARIANT_EQCASE, CTORS), _HNET_MAP(HNET_VARIANT_CTOR_TAG, CTORS), _HNET_MAP(HNET_VARIANT_CTOR_OPAQUEDATA, CTORS), _HNET_MAP(HNET_VARIANT_AIOSTATE_DATA, CTORS), _HNET_MAP(HNET_VARIANT_AIOSTATE_INIT, CTORS), _HNET_MAP(HNET_VARIANT_AIOSTATE_ACCUM, CTORS))

◆ DEFINE_HNET_VARIANT_GEN

#define DEFINE_HNET_VARIANT_GEN (   T,
  VDECL,
  VCTORS,
  VCOPY,
  VDESTROY,
  CTORCOUNT,
  VENCODE,
  VDESC,
  VWRITE,
  VREAD,
  VVISITCASE,
  VEQCASE,
  CTAGS,
  CDATA,
  CAIOSTATES,
  CAIOSTATEINIT,
  CAIOREAD 
)

◆ DEFINE_HNET_VARIANT_WITH_LABELS

#define DEFINE_HNET_VARIANT_WITH_LABELS (   T,
  CTORS... 
)    DEFINE_HNET_VARIANT_GEN(T, _HNET_MAP(HNET_VARIANT_LBL_VDECL, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR, CTORS), _HNET_MAP(HNET_VARIANT_LBL_PCOPY, CTORS), _HNET_MAP(HNET_VARIANT_LBL_PDESTROY, CTORS), _HNET_MAP(HNET_VARIANT_LBL_SUCC, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_ENCODE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_STR, CTORS), _HNET_MAP(HNET_VARIANT_LBL_WRITE_CASE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_READ_CASE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_VCASE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_EQCASE, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_TAG, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_OPAQUEDATA, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_AIOSTATE_DATA, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_AIOSTATE_INIT, CTORS), _HNET_MAP(HNET_VARIANT_LBL_CTOR_AIOSTATE_ACCUM, CTORS))

◆ DEFINE_NET_CLIENT

#define DEFINE_NET_CLIENT (   T,
  C... 
)
Value:
class T { \
private: \
int s; \
public: \
T(int fd) : s(::hobbes::net::initSession(fd, makeRPCDefs())) _HNET_MAP(_HNET_CLIENT_INIT_RPCFUNC, C) { } \
T(const std::string& host, size_t port) : T(::hobbes::net::makeConnection(host, port)) { } \
T(const std::string& host, const std::string& port) : T(::hobbes::net::makeConnection(host, port)) { } \
T(const std::string& hostport) : T(::hobbes::net::makeConnection(hostport)) { } \
virtual ~T() { closeC(); } \
int fd() const { return this->s; } \
void reconnect(int fd) { closeC(); this->s = ::hobbes::net::initSession(fd, makeRPCDefs()); } \
void reconnect(const std::string& host, size_t port) { reconnect(::hobbes::net::makeConnection(host, port)); } \
void reconnect(const std::string& host, const std::string& port) { reconnect(::hobbes::net::makeConnection(host, port)); } \
void reconnect(const std::string& hostport) { reconnect(::hobbes::net::makeConnection(hostport)); } \
\
_HNET_MAP(_HNET_CLIENT_MAKE_RPCFUNC, C) \
private: \
enum ExprIDs { \
NullExpr = 0 \
_HNET_MAP(_HNET_CLIENT_MAKE_EXPRID, C) \
}; \
static ::hobbes::net::RPCDefs makeRPCDefs() { \
::hobbes::net::RPCDefs result; \
_HNET_MAP(_HNET_CLIENT_MAKE_RPCDEF, C) \
return result; \
} \
void closeC() { \
::close(this->s); \
} \
};
hobbes::net::RPCDefs
std::vector< RPCDef > RPCDefs
Definition: net.H:128
hobbes
Definition: boot.H:7
_HNET_CLIENT_MAKE_RPCFUNC
#define _HNET_CLIENT_MAKE_RPCFUNC(n, t, _)
Definition: net.H:1154
_HNET_CLIENT_INIT_RPCFUNC
#define _HNET_CLIENT_INIT_RPCFUNC(n, t, _)
Definition: net.H:1153
hobbes::net::makeConnection
int makeConnection(const std::string &hostport)
Definition: net.H:217
hobbes::net::initSession
int initSession(int s, const RPCDefs &rpcds)
Definition: net.H:131
_HNET_CLIENT_MAKE_EXPRID
#define _HNET_CLIENT_MAKE_EXPRID(n, _, __)
Definition: net.H:1151
hobbes::net::makeConnection
int makeConnection(int s, sockaddr *saddr, size_t len)
Definition: net.H:156
_HNET_CLIENT_MAKE_RPCDEF
#define _HNET_CLIENT_MAKE_RPCDEF(n, t, e)
Definition: net.H:1152
hobbes::result
uint32_t result
Definition: regex.C:376
_HNET_MAP
#define _HNET_MAP(f, VS...)
Definition: net.H:255

◆ HNET_CMD_DEFEXPR

#define HNET_CMD_DEFEXPR   ((uint8_t)0)

◆ HNET_CMD_INVOKE

#define HNET_CMD_INVOKE   ((uint8_t)2)

◆ HNET_ENUM_CTOR_CTOR

#define HNET_ENUM_CTOR_CTOR (   n)    static const SelfT n() { return SelfT(SelfT::Enum::n); }

◆ HNET_ENUM_CTOR_DEF

#define HNET_ENUM_CTOR_DEF (   n)    n ,

◆ HNET_ENUM_CTOR_ENCODE

#define HNET_ENUM_CTOR_ENCODE (   n)
Value:
::hobbes::net::ws(#n, out); \
::hobbes::net::w((uint32_t)(Enum :: n), out); \
::hobbes::net::encode_primty("unit", out);
hobbes::net::encode_primty
void encode_primty(const char *tn, bytes *out)
Definition: net.H:299
hobbes::net::w
void w(const T &x, bytes *out)
Definition: net.H:282
out
#define out
Definition: netio.H:19
hobbes::net::ws
void ws(const bytes &x, bytes *out)
Definition: net.H:294

◆ HNET_ENUM_CTOR_STR

#define HNET_ENUM_CTOR_STR (   n)    + "|" #n

◆ HNET_ENUM_CTORC_SUCC

#define HNET_ENUM_CTORC_SUCC (   n)    +1

◆ HNET_ENUM_TOSTR_CASE

#define HNET_ENUM_TOSTR_CASE (   n)    case SelfT :: Enum :: n: o << "|" #n "|"; break;

◆ HNET_FIELD_ASYNC_READ_FIELD

#define HNET_FIELD_ASYNC_READ_FIELD (   t,
  n 
)    case FieldIndex::readAt_##n: if (::hobbes::net::io< t >::accum(s, &o->fieldStates.n, &x->n)) { o->idx = (FieldIndex)(((uint32_t)o->idx) + 1); } break;

◆ HNET_FIELD_ASYNC_READ_IDX_DEF

#define HNET_FIELD_ASYNC_READ_IDX_DEF (   _,
  n 
)    readAt_##n,

◆ HNET_FIELD_ASYNC_READ_STATE_DEC

#define HNET_FIELD_ASYNC_READ_STATE_DEC (   t,
  n 
)    ::hobbes::net::io< t >::async_read_state n;

◆ HNET_FIELD_ASYNC_READ_STATE_INIT

#define HNET_FIELD_ASYNC_READ_STATE_INIT (   t,
  n 
)    ::hobbes::net::io< t >::prepare(&o->fieldStates.n);

◆ HNET_FIELD_COUNT

#define HNET_FIELD_COUNT (   FIELDS...)    (0 _HNET_MAP(HNET_FIELDC_SUCC, FIELDS))

◆ HNET_FIELD_READS

#define HNET_FIELD_READS (   FIELDS...)    _HNET_MAP(HNET_FIELDR_SUCC, FIELDS)

◆ HNET_FIELD_WRITES

#define HNET_FIELD_WRITES (   FIELDS...)    _HNET_MAP(HNET_FIELDW_SUCC, FIELDS)

◆ HNET_FIELDC_SUCC

#define HNET_FIELDC_SUCC (   t,
  n 
)    +1

◆ HNET_FIELDR_SUCC

#define HNET_FIELDR_SUCC (   t,
  n 
)    ::hobbes::net::io< t >::read(s, &this-> n);

◆ HNET_FIELDW_SUCC

#define HNET_FIELDW_SUCC (   t,
  n 
)    ::hobbes::net::io< t >::write(s, this-> n);

◆ HNET_RESULT_FAIL

#define HNET_RESULT_FAIL   0

◆ HNET_STRUCT_FIELD

#define HNET_STRUCT_FIELD (   t,
  n 
)    t n;

◆ HNET_STRUCT_FIELD_DESC

#define HNET_STRUCT_FIELD_DESC (   t,
  n 
)    + (", " #n " : " + ::hobbes::net::io< t >::describe())

◆ HNET_STRUCT_FIELD_ENC

#define HNET_STRUCT_FIELD_ENC (   t,
  n 
)    ::hobbes::net::ws(#n, out); ::hobbes::net::w((int)-1, out); ::hobbes::net::io< t >::encode(out);

◆ HNET_VARIANT_AIOSTATE_ACCUM

#define HNET_VARIANT_AIOSTATE_ACCUM (   n,
  t 
)    case Enum::tag_##n: return ::hobbes::net::io<t>::accum(s, &o->payloadS.n##_aioS, &x->n##_data);

◆ HNET_VARIANT_AIOSTATE_DATA

#define HNET_VARIANT_AIOSTATE_DATA (   n,
  t 
)    ::hobbes::net::io<t>::async_read_state n##_aioS;

◆ HNET_VARIANT_AIOSTATE_INIT

#define HNET_VARIANT_AIOSTATE_INIT (   n,
  t 
)    case Enum::tag_##n: { new (o->payloadS.data) ::hobbes::net::io<t>::async_read_state(); ::hobbes::net::io<t>::prepare(&o->payloadS.n##_aioS); new (x->data) t(); } break;

◆ HNET_VARIANT_CTOR

#define HNET_VARIANT_CTOR (   n,
  t 
)    static SelfT n(const t & x) { SelfT r; r.tag = Enum::tag_##n; new (r.data) t(x); return r; }

◆ HNET_VARIANT_CTOR_ENCODE

#define HNET_VARIANT_CTOR_ENCODE (   n,
  t 
)
Value:
::hobbes::net::ws(#n, out); \
::hobbes::net::w((uint32_t)Enum::tag_##n, out); \
::hobbes::net::io< t >::encode(out);
hobbes::encode
void encode(const PrimitivePtr &, std::ostream &)
Definition: expr.C:1674
hobbes::net::w
void w(const T &x, bytes *out)
Definition: net.H:282
out
#define out
Definition: netio.H:19
hobbes::net::ws
void ws(const bytes &x, bytes *out)
Definition: net.H:294

◆ HNET_VARIANT_CTOR_OPAQUEDATA

#define HNET_VARIANT_CTOR_OPAQUEDATA (   n,
  t 
)    t n##_data;

◆ HNET_VARIANT_CTOR_STR

#define HNET_VARIANT_CTOR_STR (   n,
  t 
)    + "," #n ":" + ::hobbes::net::io< t >::describe()

◆ HNET_VARIANT_CTOR_TAG

#define HNET_VARIANT_CTOR_TAG (   n,
  t 
)    tag_##n,

◆ HNET_VARIANT_EQCASE

#define HNET_VARIANT_EQCASE (   n,
  t 
)    case Enum::tag_##n: return (this->n##_data == rhs.n##_data);

◆ HNET_VARIANT_LBL_CTOR

#define HNET_VARIANT_LBL_CTOR (   n,
  lbl,
  t 
)    static SelfT n(const t & x) { SelfT r; r.tag = Enum::tag_##n; new (r.data) t(x); return r; }

◆ HNET_VARIANT_LBL_CTOR_AIOSTATE_ACCUM

#define HNET_VARIANT_LBL_CTOR_AIOSTATE_ACCUM (   n,
  lbl,
  t 
)    case Enum::tag_##n: return ::hobbes::net::io<t>::accum(s, &o->payloadS.n##_aioS, &x->n##_data);

◆ HNET_VARIANT_LBL_CTOR_AIOSTATE_DATA

#define HNET_VARIANT_LBL_CTOR_AIOSTATE_DATA (   n,
  lbl,
  t 
)    ::hobbes::net::io<t>::async_read_state n##_aioS;

◆ HNET_VARIANT_LBL_CTOR_AIOSTATE_INIT

#define HNET_VARIANT_LBL_CTOR_AIOSTATE_INIT (   n,
  lbl,
  t 
)    case Enum::tag_##n: { new (o->payloadS.data) ::hobbes::net::io<t>::async_read_state(); ::hobbes::net::io<t>::prepare(&o->payloadS.n##_aioS); new (x->data) t(); } break;

◆ HNET_VARIANT_LBL_CTOR_ENCODE

#define HNET_VARIANT_LBL_CTOR_ENCODE (   n,
  lbl,
  t 
)
Value:
::hobbes::net::ws(#lbl, out); \
::hobbes::net::w((uint32_t)Enum::tag_##n, out); \
::hobbes::net::io< t >::encode(out);
hobbes::encode
void encode(const PrimitivePtr &, std::ostream &)
Definition: expr.C:1674
hobbes::net::w
void w(const T &x, bytes *out)
Definition: net.H:282
out
#define out
Definition: netio.H:19
hobbes::net::ws
void ws(const bytes &x, bytes *out)
Definition: net.H:294

◆ HNET_VARIANT_LBL_CTOR_OPAQUEDATA

#define HNET_VARIANT_LBL_CTOR_OPAQUEDATA (   n,
  lbl,
  t 
)    t n##_data;

◆ HNET_VARIANT_LBL_CTOR_STR

#define HNET_VARIANT_LBL_CTOR_STR (   n,
  lbl,
  t 
)    + "," #n ":" + ::hobbes::net::io< t >::describe()

◆ HNET_VARIANT_LBL_CTOR_TAG

#define HNET_VARIANT_LBL_CTOR_TAG (   n,
  lbl,
  t 
)    tag_##n,

◆ HNET_VARIANT_LBL_EQCASE

#define HNET_VARIANT_LBL_EQCASE (   n,
  lbl,
  t 
)    case Enum::tag_##n: return (this->n##_data == rhs.n##_data);

◆ HNET_VARIANT_LBL_PCOPY

#define HNET_VARIANT_LBL_PCOPY (   n,
  lbl,
  t 
)    case Enum::tag_##n: new (this->data) t(rhs.n##_data); break;

◆ HNET_VARIANT_LBL_PDESTROY

#define HNET_VARIANT_LBL_PDESTROY (   n,
  lbl,
  t 
)    case Enum::tag_##n: { typedef t __DT; ((__DT*)&this->n##_data)->~__DT(); } break;

◆ HNET_VARIANT_LBL_READ_CASE

#define HNET_VARIANT_LBL_READ_CASE (   n,
  lbl,
  t 
)    case Enum::tag_##n: new (this->data) t(); ::hobbes::net::io< t >::read(s, &this->n##_data); break;

◆ HNET_VARIANT_LBL_SUCC

#define HNET_VARIANT_LBL_SUCC (   n,
  lbl,
  t 
)    +1

◆ HNET_VARIANT_LBL_VCASE

#define HNET_VARIANT_LBL_VCASE (   n,
  lbl,
  t 
)    case Enum::tag_##n: return v. n (this->n##_data);

◆ HNET_VARIANT_LBL_VDECL

#define HNET_VARIANT_LBL_VDECL (   n,
  lbl,
  t 
)    virtual R n(const t & x) const = 0;

◆ HNET_VARIANT_LBL_WRITE_CASE

#define HNET_VARIANT_LBL_WRITE_CASE (   n,
  lbl,
  t 
)    case Enum::tag_##n: ::hobbes::net::io<int>::write(s, (int)this->tag); ::hobbes::net::io< t >::write(s, this->n##_data); break;

◆ HNET_VARIANT_PCOPY

#define HNET_VARIANT_PCOPY (   n,
  t 
)    case Enum::tag_##n: new (this->data) t(rhs.n##_data); break;

◆ HNET_VARIANT_PDESTROY

#define HNET_VARIANT_PDESTROY (   n,
  t 
)    case Enum::tag_##n: { typedef t __DT; ((__DT*)&this->n##_data)->~__DT(); } break;

◆ HNET_VARIANT_READ_CASE

#define HNET_VARIANT_READ_CASE (   n,
  t 
)    case Enum::tag_##n: new (this->data) t(); ::hobbes::net::io< t >::read(s, &this->n##_data); break;

◆ HNET_VARIANT_SUCC

#define HNET_VARIANT_SUCC (   n,
  t 
)    +1

◆ HNET_VARIANT_VCASE

#define HNET_VARIANT_VCASE (   n,
  t 
)    case Enum::tag_##n: return v.n (this->n##_data);

◆ HNET_VARIANT_VDECL

#define HNET_VARIANT_VDECL (   n,
  t 
)    virtual R n(const t & x) const = 0;

◆ HNET_VARIANT_WRITE_CASE

#define HNET_VARIANT_WRITE_CASE (   n,
  t 
)    case Enum::tag_##n: ::hobbes::net::io<int>::write(s, (int)this->tag); ::hobbes::net::io< t >::write(s, this->n##_data); break;

◆ HNET_VERSION

#define HNET_VERSION   ((uint32_t)0x00010000)
Generated by   doxygen 1.8.13