Select Git revision
tinyxmlparser.cpp
mstro_pool.pb-c.h 102.10 KiB
/* Generated by the protocol buffer compiler. DO NOT EDIT! */
/* Generated from: mstro_pool.proto */
#ifndef PROTOBUF_C_mstro_5fpool_2eproto__INCLUDED
#define PROTOBUF_C_mstro_5fpool_2eproto__INCLUDED
#include <protobuf-c/protobuf-c.h>
PROTOBUF_C__BEGIN_DECLS
#if PROTOBUF_C_VERSION_NUMBER < 1003000
# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
#elif 1003002 < PROTOBUF_C_MIN_COMPILER_VERSION
# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
#endif
typedef struct _Mstro__Pool__UUID Mstro__Pool__UUID;
typedef struct _Mstro__Pool__Appid Mstro__Pool__Appid;
typedef struct _Mstro__Pool__Apptoken Mstro__Pool__Apptoken;
typedef struct _Mstro__Pool__VSMAnnouncement Mstro__Pool__VSMAnnouncement;
typedef struct _Mstro__Pool__Join Mstro__Pool__Join;
typedef struct _Mstro__Pool__Welcome Mstro__Pool__Welcome;
typedef struct _Mstro__Pool__Leave Mstro__Pool__Leave;
typedef struct _Mstro__Pool__EmergencyDetach Mstro__Pool__EmergencyDetach;
typedef struct _Mstro__Pool__Resolve Mstro__Pool__Resolve;
typedef struct _Mstro__Pool__ResolveReply Mstro__Pool__ResolveReply;
typedef struct _Mstro__Pool__Bye Mstro__Pool__Bye;
typedef struct _Mstro__Pool__Declare Mstro__Pool__Declare;
typedef struct _Mstro__Pool__DeclareAck Mstro__Pool__DeclareAck;
typedef struct _Mstro__Pool__Timestamp Mstro__Pool__Timestamp;
typedef struct _Mstro__Pool__GroupMembers Mstro__Pool__GroupMembers;
typedef struct _Mstro__Pool__AVal Mstro__Pool__AVal;
typedef struct _Mstro__Pool__KvEntry Mstro__Pool__KvEntry;
typedef struct _Mstro__Pool__Attributes Mstro__Pool__Attributes;
typedef struct _Mstro__Pool__Attributes__Map Mstro__Pool__Attributes__Map;
typedef struct _Mstro__Pool__Seal Mstro__Pool__Seal;
typedef struct _Mstro__Pool__SealGroup Mstro__Pool__SealGroup;
typedef struct _Mstro__Pool__Offer Mstro__Pool__Offer;
typedef struct _Mstro__Pool__Withdraw Mstro__Pool__Withdraw;
typedef struct _Mstro__Pool__Dispose Mstro__Pool__Dispose;
typedef struct _Mstro__Pool__Require Mstro__Pool__Require;
typedef struct _Mstro__Pool__Retract Mstro__Pool__Retract;
typedef struct _Mstro__Pool__PoolOpAck Mstro__Pool__PoolOpAck;
typedef struct _Mstro__Pool__Demand Mstro__Pool__Demand;
typedef struct _Mstro__Pool__DemandAttr Mstro__Pool__DemandAttr;
typedef struct _Mstro__Pool__DemandAttrRes Mstro__Pool__DemandAttrRes;
typedef struct _Mstro__Pool__TransportMethods Mstro__Pool__TransportMethods;
typedef struct _Mstro__Pool__InitiateTransfer Mstro__Pool__InitiateTransfer;
typedef struct _Mstro__Pool__TransferTicketGFS Mstro__Pool__TransferTicketGFS;
typedef struct _Mstro__Pool__TransferTicketUDJ Mstro__Pool__TransferTicketUDJ;
typedef struct _Mstro__Pool__TransferTicketMIO Mstro__Pool__TransferTicketMIO;
typedef struct _Mstro__Pool__RDMAHandle Mstro__Pool__RDMAHandle;
typedef struct _Mstro__Pool__TransferTicketOFI Mstro__Pool__TransferTicketOFI;
typedef struct _Mstro__Pool__TransferTicket Mstro__Pool__TransferTicket;
typedef struct _Mstro__Pool__TransferCompleted Mstro__Pool__TransferCompleted;
typedef struct _Mstro__Pool__CDOSelector Mstro__Pool__CDOSelector;
typedef struct _Mstro__Pool__SubscriptionHandle Mstro__Pool__SubscriptionHandle;
typedef struct _Mstro__Pool__Subscribe Mstro__Pool__Subscribe;
typedef struct _Mstro__Pool__SubscribeAck Mstro__Pool__SubscribeAck;
typedef struct _Mstro__Pool__Unsubscribe Mstro__Pool__Unsubscribe;
typedef struct _Mstro__Pool__Event Mstro__Pool__Event;
typedef struct _Mstro__Pool__EventAck Mstro__Pool__EventAck;
typedef struct _Mstro__Pool__Configure Mstro__Pool__Configure;
typedef struct _Mstro__Pool__CDODemandable Mstro__Pool__CDODemandable;
typedef struct _Mstro__Pool__CDOWithdrawable Mstro__Pool__CDOWithdrawable;
typedef struct _Mstro__Pool__Log Mstro__Pool__Log;
typedef struct _Mstro__Pool__Query Mstro__Pool__Query;
typedef struct _Mstro__Pool__QueryRes Mstro__Pool__QueryRes;
typedef struct _Mstro__Pool__MstroMsg Mstro__Pool__MstroMsg;typedef struct _Mstro__Pool__MstroMsg__Opts Mstro__Pool__MstroMsg__Opts;
typedef struct _Mstro__Pool__FragmentedMsg Mstro__Pool__FragmentedMsg;
/* --- enums --- */
typedef enum _Mstro__Pool__PoolOpAck__PoolOpStatus {
MSTRO__POOL__POOL_OP_ACK__POOL_OP_STATUS__OK = 0,
/*
* more specific ones to follow
*/
MSTRO__POOL__POOL_OP_ACK__POOL_OP_STATUS__FAIL = 1
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__POOL_OP_ACK__POOL_OP_STATUS)
} Mstro__Pool__PoolOpAck__PoolOpStatus;
/*
** operations that the Ack can be for
*/
typedef enum _Mstro__Pool__PoolOpAck__PoolOp {
MSTRO__POOL__POOL_OP_ACK__POOL_OP__INVALID_POOL_OP = 0,
/*
* Note: DECLARE is acknowledged by DeclareAck
*/
MSTRO__POOL__POOL_OP_ACK__POOL_OP__SEAL = 1,
MSTRO__POOL__POOL_OP_ACK__POOL_OP__OFFER = 2,
MSTRO__POOL__POOL_OP_ACK__POOL_OP__REQUIRE = 3,
MSTRO__POOL__POOL_OP_ACK__POOL_OP__RETRACT = 4,
MSTRO__POOL__POOL_OP_ACK__POOL_OP__WITHDRAW = 5,
/*
* Note: Subscribe is acknowledged by SubscribeAck
*/
MSTRO__POOL__POOL_OP_ACK__POOL_OP__UNSUBSCRIBE = 6
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__POOL_OP_ACK__POOL_OP)
} Mstro__Pool__PoolOpAck__PoolOp;
/*
** The kinds of transports supported
*/
typedef enum _Mstro__Pool__TransportKind {
MSTRO__POOL__TRANSPORT_KIND__INVALID_TRANSPORT_KIND = 0,
MSTRO__POOL__TRANSPORT_KIND__GFS = 1,
MSTRO__POOL__TRANSPORT_KIND__UDJ = 2,
MSTRO__POOL__TRANSPORT_KIND__MIO = 3,
MSTRO__POOL__TRANSPORT_KIND__OFI = 4,
MSTRO__POOL__TRANSPORT_KIND__NUMBER_OF_KINDS = 5
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__TRANSPORT_KIND)
} Mstro__Pool__TransportKind;
/*
** Events reported to subscribers
* Events described as 'X occured' are signaled to subscribers after
* the message has been inspected, but before actions in the PM are
* taken.
* We intentionally leave the small indices unused at this time, to be
* able to select frequently used ones in the cheap-to-encode indices
* 1..15 in a later revision of the protocol.
*/
typedef enum _Mstro__Pool__EventKind {
MSTRO__POOL__EVENT_KIND__INVALID_EVENT = 0,
/*
** DECLARE request occurred
*/
MSTRO__POOL__EVENT_KIND__DECLARE = 16,
/*
** DECLARE_ACK is about to be sent
*/
MSTRO__POOL__EVENT_KIND__DECLARE_ACK = 17,
/*
** SEAL request occured
*/
MSTRO__POOL__EVENT_KIND__SEAL = 18,
/*
** SEAL-GROUP request occured */
MSTRO__POOL__EVENT_KIND__SEAL_GROUP = 19,
/*
** OFFER message occured
*/
MSTRO__POOL__EVENT_KIND__OFFER = 20,
/*
** REQUIRE message occured
*/
MSTRO__POOL__EVENT_KIND__REQUIRE = 21,
/*
** WITHDRAW message occured
*/
MSTRO__POOL__EVENT_KIND__WITHDRAW = 22,
/*
** DEMAND message occured
*/
MSTRO__POOL__EVENT_KIND__DEMAND = 23,
/*
** RETRACT message occured
*/
MSTRO__POOL__EVENT_KIND__RETRACT = 24,
/*
** DISPOSE message occured
*/
MSTRO__POOL__EVENT_KIND__DISPOSE = 25,
/*
** TRANSPORT-INIT message occured
*/
MSTRO__POOL__EVENT_KIND__TRANSPORT_INIT = 26,
/*
** TRANSPORT-TICKET message occured
*/
MSTRO__POOL__EVENT_KIND__TRANSPORT_TICKET = 27,
/*
** TRANSFER-COMPLETED message occured on PM
*/
MSTRO__POOL__EVENT_KIND__TRANSFER_COMPLETED = 28,
/*
** a new app join request occurred
*/
MSTRO__POOL__EVENT_KIND__APP_JOIN = 32,
/*
** a new app was welcomed
*/
MSTRO__POOL__EVENT_KIND__APP_WELCOME = 33,
/*
** a pool app is asking to leave
*/
MSTRO__POOL__EVENT_KIND__APP_LEAVE = 34,
/*
** a pool app is granted leave
*/
MSTRO__POOL__EVENT_KIND__APP_BYE = 35,
/*
** a subscribe was posted
*/
MSTRO__POOL__EVENT_KIND__SUBSCRIBE = 36,
/*
** an unsubscribe was posted
*/
MSTRO__POOL__EVENT_KIND__UNSUBSCRIBE = 37,
/*
** pool checkpoint starting
*/
/*
* there is no CHECKPOINT_DONE event as no listener would be
* able to take notice of it
*/
MSTRO__POOL__EVENT_KIND__CHECKPOINT = 38 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__EVENT_KIND)
} Mstro__Pool__EventKind;
/* --- messages --- */
/*
**
**@addtogroup MSTRO_Core
**@{
**
**
**@defgroup MSTRO_Pool_Protocol Maestro Pool Protocol
**@{
** This is the Pool protocol, interface between Maestro API and the low-level
** network layer
**
**
** A uuid, two quadwords
*/
struct _Mstro__Pool__UUID
{
ProtobufCMessage base;
uint64_t qw0;
uint64_t qw1;
};
#define MSTRO__POOL__UUID__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__uuid__descriptor) \
, 0, 0 }
/*
** An ID of a pool participant.
**
** Should be considered opaque to the user; some are reserved and
** defined in the implementation (e.g., the pool manager's ID(s)).
**
** Assigned at the time the Apptoken is handed out to new participants.
*/
struct _Mstro__Pool__Appid
{
ProtobufCMessage base;
uint64_t id;
};
#define MSTRO__POOL__APPID__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__appid__descriptor) \
, 0 }
/*
** An application token.
**
** Every participant of the pool is assigned an Apptoken, in
** particular an appid at WELCOME time. The reserved fields are for
** authorization token usage (rdma credential and a cookie)
*/
struct _Mstro__Pool__Apptoken
{
ProtobufCMessage base;
Mstro__Pool__Appid *appid;
uint64_t reserved1;
uint64_t reserved2;
};
#define MSTRO__POOL__APPTOKEN__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__apptoken__descriptor) \
, NULL, 0, 0 }
/*
** Variable size message announcement.
** ** Some short messages may need to announce that their payload will
** be sent as a stream of fragmented messages. This is done by
** filling in a VSMAnnouncement slot.
**
** We assume that a dedicated channel is being used (e.g., by using a
** pre-agreed OFI tag) to segregate all fragments from normal
** traffic.
*/
struct _Mstro__Pool__VSMAnnouncement
{
ProtobufCMessage base;
/*
** the total size of the data that is in the FragmentedMsg
* stream. It allows the receiver to prepare the appropriate
* destination buffer. Optional for fully dynamic fragmentation
*/
uint64_t total_size;
/*
** Total number of fragments. Optional for fully dynamic fragmentation
*/
uint64_t num_total_fragments;
/*
** One or more framnet sizes of subsequent messages
*/
size_t n_fragment_size;
uint64_t *fragment_size;
};
#define MSTRO__POOL__VSMANNOUNCEMENT__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__vsmannouncement__descriptor) \
, 0, 0, 0,NULL }
/*
** A join message. *
*/
struct _Mstro__Pool__Join
{
ProtobufCMessage base;
/*
** protocol version of app
*/
uint32_t protocol_version;
/*
** list of endpoints of app
*/
char *serialized_endpoint;
/*
** transport methods that this application is ready to accept
*/
Mstro__Pool__TransportMethods *transport_methods;
/*
** the name of the component
*/
char *component_name;
};
#define MSTRO__POOL__JOIN__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__join__descriptor) \
, 0, (char *)protobuf_c_empty_string, NULL, (char *)protobuf_c_empty_string }
/*
** Welcome message: assigns the app token *
*/
struct _Mstro__Pool__Welcome
{
ProtobufCMessage base;
/*
**< the application token that must be used to communicate further on
*/
Mstro__Pool__Apptoken *token;};
#define MSTRO__POOL__WELCOME__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__welcome__descriptor) \
, NULL }
/*
** Leave message: app wants to detach from pool *
*/
struct _Mstro__Pool__Leave
{
ProtobufCMessage base;
};
#define MSTRO__POOL__LEAVE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__leave__descriptor) \
}
/*
** Emergency Detach: app is crashing, but tries to let us know in
* case we can deal with it
*/
struct _Mstro__Pool__EmergencyDetach
{
ProtobufCMessage base;
char *reason;
};
#define MSTRO__POOL__EMERGENCY_DETACH__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__emergency_detach__descriptor) \
, (char *)protobuf_c_empty_string }
typedef enum {
MSTRO__POOL__RESOLVE__QUERY__NOT_SET = 0,
MSTRO__POOL__RESOLVE__QUERY_CDOID = 2,
MSTRO__POOL__RESOLVE__QUERY_APPID = 3
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__RESOLVE__QUERY)
} Mstro__Pool__Resolve__QueryCase;
/*
** Resolve data that is opaque to the end user but appears in
* protocol messages
*/
struct _Mstro__Pool__Resolve
{
ProtobufCMessage base;
/*
** component-local unique identifier for request
*/
uint64_t serial;
Mstro__Pool__Resolve__QueryCase query_case;
union {
Mstro__Pool__UUID *cdoid;
uint64_t appid;
};
};
#define MSTRO__POOL__RESOLVE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__resolve__descriptor) \
, 0, MSTRO__POOL__RESOLVE__QUERY__NOT_SET, {0} }
typedef enum {
MSTRO__POOL__RESOLVE_REPLY__RESULT__NOT_SET = 0,
MSTRO__POOL__RESOLVE_REPLY__RESULT_NAME = 2
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__RESOLVE_REPLY__RESULT)
} Mstro__Pool__ResolveReply__ResultCase;
/*
** Reply to a resolve request
*/struct _Mstro__Pool__ResolveReply
{
ProtobufCMessage base;
Mstro__Pool__Resolve *query;
Mstro__Pool__ResolveReply__ResultCase result_case;
union {
char *name;
};
};
#define MSTRO__POOL__RESOLVE_REPLY__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__resolve_reply__descriptor) \
, NULL, MSTRO__POOL__RESOLVE_REPLY__RESULT__NOT_SET, {0} }
/*
** Bye message: Pool manager agrees that app has been detached. *
*/
struct _Mstro__Pool__Bye
{
ProtobufCMessage base;
};
#define MSTRO__POOL__BYE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__bye__descriptor) \
}
/*
** Declaring a CDO
**
** A unique (for the sender) serial number and the CDO name are sent
** to the pool manager *
*/
struct _Mstro__Pool__Declare
{
ProtobufCMessage base;
uint64_t serial;
char *cdo_name;
};
#define MSTRO__POOL__DECLARE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__declare__descriptor) \
, 0, (char *)protobuf_c_empty_string }
/*
** Declaration reply
**
** The serial is the number used in the DECLARE call
** previously. The reply will contain the pool-manager assigned uuid.
*/
struct _Mstro__Pool__DeclareAck
{
ProtobufCMessage base;
/*
**< the (app-local) serial used in the DECLARE
* being acknowledged
*/
uint64_t serial;
/*
**< The global CDOID for the declared CDO
*/
Mstro__Pool__UUID *cdoid;
/*
**< channel identifier to be used for VSM
* messages relatedf to this CDOID
*/
uint64_t channel;
};
#define MSTRO__POOL__DECLARE_ACK__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__declare_ack__descriptor) \
, 0, NULL, 0 }
/*
** Built-in type corresponding to @ref mstro_timestamp
*/
struct _Mstro__Pool__Timestamp
{
ProtobufCMessage base;
int64_t sec;
int32_t nsec;
int32_t offset;
};
#define MSTRO__POOL__TIMESTAMP__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__timestamp__descriptor) \
, 0, 0, 0 }
struct _Mstro__Pool__GroupMembers
{
ProtobufCMessage base;
size_t n_declared_members;
Mstro__Pool__UUID **declared_members;
size_t n_undeclared_members;
char **undeclared_members;
Mstro__Pool__CDOSelector *sel;
};
#define MSTRO__POOL__GROUP_MEMBERS__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__group_members__descriptor) \
, 0,NULL, 0,NULL, NULL }
typedef enum {
MSTRO__POOL__AVAL__VAL__NOT_SET = 0,
MSTRO__POOL__AVAL__VAL_BOOL = 1,
MSTRO__POOL__AVAL__VAL_INT32 = 2,
MSTRO__POOL__AVAL__VAL_INT64 = 3,
MSTRO__POOL__AVAL__VAL_UINT32 = 4,
MSTRO__POOL__AVAL__VAL_UINT64 = 5,
MSTRO__POOL__AVAL__VAL_FLOAT = 6,
MSTRO__POOL__AVAL__VAL_DOUBLE = 7,
MSTRO__POOL__AVAL__VAL_STRING = 8,
MSTRO__POOL__AVAL__VAL_BYTES = 9,
MSTRO__POOL__AVAL__VAL_TIMESTAMP = 10
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__AVAL__VAL)
} Mstro__Pool__AVal__ValCase;
struct _Mstro__Pool__AVal
{
ProtobufCMessage base;
Mstro__Pool__AVal__ValCase val_case;
union {
protobuf_c_boolean bool_;
int32_t int32;
int64_t int64;
uint32_t uint32;
uint64_t uint64;
float float_;
double double_;
char *string;
/*
* protobuf limits this to 2^32; this is used for mstro_blob attributes
*/
ProtobufCBinaryData bytes;
Mstro__Pool__Timestamp *timestamp;
};
};
#define MSTRO__POOL__AVAL__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__aval__descriptor) \
, MSTRO__POOL__AVAL__VAL__NOT_SET, {0} }
/*
** Attribute key-value entry
*/
struct _Mstro__Pool__KvEntry
{
ProtobufCMessage base;
char *key;
Mstro__Pool__AVal *val;
};
#define MSTRO__POOL__KV_ENTRY__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__kv_entry__descriptor) \
, (char *)protobuf_c_empty_string, NULL }
struct _Mstro__Pool__Attributes__Map
{
ProtobufCMessage base;
size_t n_map;
Mstro__Pool__KvEntry **map;
};
#define MSTRO__POOL__ATTRIBUTES__MAP__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__attributes__map__descriptor) \
, 0,NULL }
typedef enum {
MSTRO__POOL__ATTRIBUTES__VAL__NOT_SET = 0,
MSTRO__POOL__ATTRIBUTES__VAL_YAML_STRING = 2,
MSTRO__POOL__ATTRIBUTES__VAL_KV_MAP = 3
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__ATTRIBUTES__VAL)
} Mstro__Pool__Attributes__ValCase;
/*
** Attributes are either a single big YAML string or a key/value
* table mapping attribute name to AVal instance.
* As usual, keys are interpreted as absolute if the start with '.'
* (PERIOD), and relative to the DEFAULT_NAMESPACE if not.
*/
struct _Mstro__Pool__Attributes
{
ProtobufCMessage base;
char *default_namespace;
Mstro__Pool__Attributes__ValCase val_case;
union {
char *yaml_string;
Mstro__Pool__Attributes__Map *kv_map;
};
};
#define MSTRO__POOL__ATTRIBUTES__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__attributes__descriptor) \
, (char *)protobuf_c_empty_string, MSTRO__POOL__ATTRIBUTES__VAL__NOT_SET, {0} }
/*
** Seal a CDO.
**
** Seal can be a variable-sized message.
*/
struct _Mstro__Pool__Seal
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
Mstro__Pool__Attributes *attributes;
};
#define MSTRO__POOL__SEAL__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__seal__descriptor) \
, NULL, NULL }
/*
** Seal a CDO.
**
** SealGroup can be a variable-sized message.
*/
struct _Mstro__Pool__SealGroup
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
Mstro__Pool__Attributes *attributes;
};
#define MSTRO__POOL__SEAL_GROUP__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__seal_group__descriptor) \
, NULL, NULL }
/*
** Offer a CDO
*/
struct _Mstro__Pool__Offer
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__OFFER__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__offer__descriptor) \
, NULL }
/*
** Withdraw a CDO.
*/
struct _Mstro__Pool__Withdraw
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__WITHDRAW__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__withdraw__descriptor) \
, NULL }
/*
** Dispose a CDO.
*/
struct _Mstro__Pool__Dispose
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__DISPOSE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__dispose__descriptor) \
, NULL }
/*
** Require a CDO.
*/
struct _Mstro__Pool__Require
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__REQUIRE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__require__descriptor) \
, NULL }
/*
** Retract a CDO. **
*/
struct _Mstro__Pool__Retract
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__RETRACT__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__retract__descriptor) \
, NULL }
typedef enum {
MSTRO__POOL__POOL_OP_ACK__OPERAND__NOT_SET = 0,
MSTRO__POOL__POOL_OP_ACK__OPERAND_CDOID = 2,
MSTRO__POOL__POOL_OP_ACK__OPERAND_HANDLE = 3
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__POOL_OP_ACK__OPERAND)
} Mstro__Pool__PoolOpAck__OperandCase;
typedef enum {
MSTRO__POOL__POOL_OP_ACK__PAYLOAD__NOT_SET = 0,
MSTRO__POOL__POOL_OP_ACK__PAYLOAD_UPDATED_ATTRIBUTES = 5
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__POOL_OP_ACK__PAYLOAD)
} Mstro__Pool__PoolOpAck__PayloadCase;
/*
** Pool manager responses for pool operations.
**
** Since no operation can be done twice from the same app on the same
** CDO it's sufficient to have a single ACK message type for all of
** them.
*/
struct _Mstro__Pool__PoolOpAck
{
ProtobufCMessage base;
/*
**< CDO operation this refers to
*/
Mstro__Pool__PoolOpAck__PoolOp op;
/*
**< status value
*/
Mstro__Pool__PoolOpAck__PoolOpStatus status;
Mstro__Pool__PoolOpAck__OperandCase operand_case;
union {
/*
**< ID that the event relates to
*/
Mstro__Pool__UUID *cdoid;
Mstro__Pool__SubscriptionHandle *handle;
};
Mstro__Pool__PoolOpAck__PayloadCase payload_case;
union {
Mstro__Pool__Attributes *updated_attributes;
};
};
#define MSTRO__POOL__POOL_OP_ACK__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__pool_op_ack__descriptor) \
, MSTRO__POOL__POOL_OP_ACK__POOL_OP__INVALID_POOL_OP, MSTRO__POOL__POOL_OP_ACK__POOL_OP_STATUS__OK, MSTRO__POOL__POOL_OP_ACK__OPERAND__NOT_SET, {0}, MSTRO__POOL__POOL_OP_ACK__PAYLOAD__NOT_SET, {0} }
/*
** Demand a CDO. Start of triangle-4step-protocol.
*/
struct _Mstro__Pool__Demand
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__DEMAND__INIT \ { PROTOBUF_C_MESSAGE_INIT (&mstro__pool__demand__descriptor) \
, NULL }
/*
** Demand a CDO's attributes
*/
struct _Mstro__Pool__DemandAttr
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__DEMAND_ATTR__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__demand_attr__descriptor) \
, NULL }
/*
** Result of a DemandAttr request. May be a VSM message.
*/
struct _Mstro__Pool__DemandAttrRes
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
Mstro__Pool__Attributes *attributes;
};
#define MSTRO__POOL__DEMAND_ATTR_RES__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__demand_attr_res__descriptor) \
, NULL, NULL }
/*
** A way to inform about the order of preference of transport
*/
struct _Mstro__Pool__TransportMethods
{
ProtobufCMessage base;
/*
* transport kinds supported, in order of preference
*/
size_t n_supported;
Mstro__Pool__TransportKind *supported;
};
#define MSTRO__POOL__TRANSPORT_METHODS__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__transport_methods__descriptor) \
, 0,NULL }
/*
** Request from pool manager to an arbitrary app to perform a transfer.
**
** This is step 2 of the triangle-4step-protocol.
**
** The cdoid referenced must be local on the recipient of this
** message. Request is to create a ticket for the app referenced in
** dst_serialized_endpoint.
*/
struct _Mstro__Pool__InitiateTransfer
{
ProtobufCMessage base;
/*
** CDO ID that should be transferred
*/
Mstro__Pool__UUID *cdoid;
/*
** Destination App Id
*/
Mstro__Pool__Appid *dst_appid;
/*
** contact information for destination app */
char *dst_serialized_endpoint;
/*
** Attributes that the destination required (in particular desired
* memory layer or layout properties of the recipient)
*/
Mstro__Pool__Attributes *dst_attributes;
/*
** transport methods that the DST is ready to accept
*/
Mstro__Pool__TransportMethods *methods;
/*
** Keep local copy. 1 means cp, 0 means mv
*/
protobuf_c_boolean cp;
/*
** Ensure an OFFER happens at the recipient, so that PM can rely on
* it being available at DST_APPID after completed transfer
*/
protobuf_c_boolean force_offer;
};
#define MSTRO__POOL__INITIATE_TRANSFER__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__initiate_transfer__descriptor) \
, NULL, NULL, (char *)protobuf_c_empty_string, NULL, NULL, 0, 0 }
struct _Mstro__Pool__TransferTicketGFS
{
ProtobufCMessage base;
char *path;
protobuf_c_boolean keep_file;
};
#define MSTRO__POOL__TRANSFER_TICKET_GFS__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__transfer_ticket_gfs__descriptor) \
, (char *)protobuf_c_empty_string, 0 }
struct _Mstro__Pool__TransferTicketUDJ
{
ProtobufCMessage base;
char *reserved;
};
#define MSTRO__POOL__TRANSFER_TICKET_UDJ__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__transfer_ticket_udj__descriptor) \
, (char *)protobuf_c_empty_string }
struct _Mstro__Pool__TransferTicketMIO
{
ProtobufCMessage base;
ProtobufCBinaryData objid;
protobuf_c_boolean keep_obj;
/*
* semaphore id, indicates dst object objid is ready to be read
*/
ProtobufCBinaryData semid;
};
#define MSTRO__POOL__TRANSFER_TICKET_MIO__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__transfer_ticket_mio__descriptor) \
, {0,NULL}, 0, {0,NULL} }
/*
* Encapsulating the data obtained by fi_mr_reg (and fi_mr_regv later)
* for an RDMA memory registation
*/
struct _Mstro__Pool__RDMAHandle
{
ProtobufCMessage base;
/* * oneof addr {
*/
/*
* placeholder for repeated add/offset pairs 'iov'
* };
*/
uint64_t single;
/*
* the memory access key obtained, length is endpoint specific (see
* from fi->domain_attr->mr_key_size)
*/
ProtobufCBinaryData mr_key;
};
#define MSTRO__POOL__RDMAHANDLE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__rdmahandle__descriptor) \
, 0, {0,NULL} }
/*
* The simplest possible ticket on OFI: SRC provides RMDA READ information for DST
*/
struct _Mstro__Pool__TransferTicketOFI
{
ProtobufCMessage base;
Mstro__Pool__RDMAHandle *h;
Mstro__Pool__Appid *dstid;
};
#define MSTRO__POOL__TRANSFER_TICKET_OFI__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__transfer_ticket_ofi__descriptor) \
, NULL, NULL }
typedef enum {
MSTRO__POOL__TRANSFER_TICKET__TICKET__NOT_SET = 0,
MSTRO__POOL__TRANSFER_TICKET__TICKET_GFS = 6,
MSTRO__POOL__TRANSFER_TICKET__TICKET_UDJ = 7,
MSTRO__POOL__TRANSFER_TICKET__TICKET_MIO = 8,
MSTRO__POOL__TRANSFER_TICKET__TICKET_OFI = 9
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__TRANSFER_TICKET__TICKET)
} Mstro__Pool__TransferTicket__TicketCase;
/*
** A transfer ticket.
**
** This is step 3 of the triangle-4step-protocol.
*/
struct _Mstro__Pool__TransferTicket
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
Mstro__Pool__Appid *srcid;
/*
* set if ticket issuer wants to receive a TransferCompleted message
*/
protobuf_c_boolean want_completion;
/*
* how to reach ticket issuer if TransferCompleted is to be sent
*/
char *src_serialized_endpoint;
/*
* FIXME: this duplicates some of the enum type that the oneof union generates
*/
Mstro__Pool__TransportKind method;
/*
* FIXME: proper attribute structure, plus eventual Mamba array info
*/
int64_t data_size;
Mstro__Pool__Attributes *attributes;
/*
** Ensure an OFFER happens at the recipient, so that PM can rely on * it being available at DST_APPID after completed transfer
*/
protobuf_c_boolean force_offer;
Mstro__Pool__TransferTicket__TicketCase ticket_case;
union {
Mstro__Pool__TransferTicketGFS *gfs;
Mstro__Pool__TransferTicketUDJ *udj;
Mstro__Pool__TransferTicketMIO *mio;
Mstro__Pool__TransferTicketOFI *ofi;
};
};
#define MSTRO__POOL__TRANSFER_TICKET__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__transfer_ticket__descriptor) \
, NULL, NULL, 0, (char *)protobuf_c_empty_string, MSTRO__POOL__TRANSPORT_KIND__INVALID_TRANSPORT_KIND, 0, NULL, 0, MSTRO__POOL__TRANSFER_TICKET__TICKET__NOT_SET, {0} }
/*
** A notification of completed transport.
**
** This is step 4 of the triangle-4step-protocol.
**
** It will be sent to the pool manager and possibly to the transfer
** source. dst_serialized_endpoint is an identifier for the app who
** has successfully received the data.
*/
struct _Mstro__Pool__TransferCompleted
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
/*
* application ID that served it to us
*/
Mstro__Pool__Appid *srcid;
};
#define MSTRO__POOL__TRANSFER_COMPLETED__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__transfer_completed__descriptor) \
, NULL, NULL }
typedef enum {
MSTRO__POOL__CDOSELECTOR__SEL__NOT_SET = 0,
MSTRO__POOL__CDOSELECTOR__SEL_REGEX = 1,
MSTRO__POOL__CDOSELECTOR__SEL_CDOID = 2,
MSTRO__POOL__CDOSELECTOR__SEL_QUERY = 3
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__CDOSELECTOR__SEL)
} Mstro__Pool__CDOSelector__SelCase;
/*
** Selection of CDOs.
**
** Currently supports a regex on the name or a list of CDO-IDs, but
** could be extended to a Boolean predicate query.
*/
struct _Mstro__Pool__CDOSelector
{
ProtobufCMessage base;
Mstro__Pool__CDOSelector__SelCase sel_case;
union {
char *regex;
Mstro__Pool__UUID *cdoid;
/*
* should also have a more specialized key-value-match structure
*/
char *query;
};
};
#define MSTRO__POOL__CDOSELECTOR__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__cdoselector__descriptor) \
, MSTRO__POOL__CDOSELECTOR__SEL__NOT_SET, {0} }
/*
** Subscriptions are referred to by a pool-manager assigned handle
*/
struct _Mstro__Pool__SubscriptionHandle
{
ProtobufCMessage base;
uint64_t id;
};
#define MSTRO__POOL__SUBSCRIPTION_HANDLE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__subscription_handle__descriptor) \
, 0 }
/*
** CDO event subscription request
*/
struct _Mstro__Pool__Subscribe
{
ProtobufCMessage base;
/*
** choice of CDOs that should be matched. Can be empty to indicate:
* no restrictions
*/
size_t n_selector;
Mstro__Pool__CDOSelector **selector;
/*
** event kind(s) that should be matched
*/
size_t n_events;
Mstro__Pool__EventKind *events;
/*
** whether event notification is supposed to be block until the
* reception has been acknowledged. Default is FALSE
*/
protobuf_c_boolean require_event_ack;
/*
** IDs do not need to be resolved to names
*/
protobuf_c_boolean no_resolve;
/*
** Signal event before handling event cause
*/
protobuf_c_boolean signal_before;
/*
** sender side identifier, used to match incoming subscription
* handle with subscription request
*/
uint64_t local_id;
};
#define MSTRO__POOL__SUBSCRIBE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__subscribe__descriptor) \
, 0,NULL, 0,NULL, 0, 0, 0, 0 }
/*
** Subscription reply
**
** The serial is the number used in the SUBSCRIBE message
** previously. The reply will contain the pool-manager assigned handle.
*/
struct _Mstro__Pool__SubscribeAck
{
ProtobufCMessage base;
/*
** the (app-local) serial used in the SUBCRIBE being acknowledged
*/
uint64_t serial;
/*
** The global Subscription handle assigned */
Mstro__Pool__SubscriptionHandle *handle;
};
#define MSTRO__POOL__SUBSCRIBE_ACK__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__subscribe_ack__descriptor) \
, 0, NULL }
/*
** CDO event unsubscription
*/
struct _Mstro__Pool__Unsubscribe
{
ProtobufCMessage base;
Mstro__Pool__SubscriptionHandle *subscription_handle;
};
#define MSTRO__POOL__UNSUBSCRIBE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__unsubscribe__descriptor) \
, NULL }
typedef enum {
MSTRO__POOL__EVENT__PAYLOAD__NOT_SET = 0,
MSTRO__POOL__EVENT__PAYLOAD_DECLARE = 16,
MSTRO__POOL__EVENT__PAYLOAD_DECLARE_ACK = 17,
MSTRO__POOL__EVENT__PAYLOAD_SEAL = 18,
MSTRO__POOL__EVENT__PAYLOAD_SEAL_GROUP = 19,
MSTRO__POOL__EVENT__PAYLOAD_OFFER = 20,
MSTRO__POOL__EVENT__PAYLOAD_REQUIRE = 21,
MSTRO__POOL__EVENT__PAYLOAD_WITHDRAW = 22,
MSTRO__POOL__EVENT__PAYLOAD_DEMAND = 23,
MSTRO__POOL__EVENT__PAYLOAD_RETRACT = 24,
MSTRO__POOL__EVENT__PAYLOAD_DISPOSE = 25,
MSTRO__POOL__EVENT__PAYLOAD_TRANSPORT_INIT = 26,
MSTRO__POOL__EVENT__PAYLOAD_TRANSPORT_TICKET = 27,
MSTRO__POOL__EVENT__PAYLOAD_TRANSFER_COMPLETED = 28,
MSTRO__POOL__EVENT__PAYLOAD_JOIN = 32,
MSTRO__POOL__EVENT__PAYLOAD_WELCOME = 33,
MSTRO__POOL__EVENT__PAYLOAD_LEAVE = 34,
MSTRO__POOL__EVENT__PAYLOAD_BYE = 35,
MSTRO__POOL__EVENT__PAYLOAD_SUBSCRIBE = 36,
MSTRO__POOL__EVENT__PAYLOAD_UNSUBSCRIBE = 37
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__EVENT__PAYLOAD)
} Mstro__Pool__Event__PayloadCase;
/*
** Events that match a subscription
*/
struct _Mstro__Pool__Event
{
ProtobufCMessage base;
/*
** the (workflow-unique) event id.
*IDs can be reused over the course of a workflow.
*/
Mstro__Pool__SubscriptionHandle *subscription_handle;
uint64_t serial;
/*
** The kind of event
*/
Mstro__Pool__EventKind kind;
/*
** the application that caused the event.
*Can be invalid or pool manager, or a joined component
*/
Mstro__Pool__Appid *origin_id;
/*
** the CDO concerned. Will be unset for non-CDO events
*/
char *cdo_name; Mstro__Pool__Event__PayloadCase payload_case;
union {
/*
** for kind DECLARE
*/
Mstro__Pool__Declare *declare;
/*
** for kind DECLARE_ACK
*/
Mstro__Pool__DeclareAck *declare_ack;
/*
** for kind SEAL
*/
Mstro__Pool__Seal *seal;
/*
** for kind SEAL_GROUP
*/
Mstro__Pool__SealGroup *seal_group;
/*
** for OFFER
*/
Mstro__Pool__Offer *offer;
/*
** for REQUIRE
*/
Mstro__Pool__Require *require;
/*
** for WITHDRAW
*/
Mstro__Pool__Withdraw *withdraw;
/*
** for DEMAND
*/
Mstro__Pool__Demand *demand;
/*
** for RETRACT
*/
Mstro__Pool__Retract *retract;
/*
** for DISPOSE
*/
Mstro__Pool__Dispose *dispose;
/*
** for TRANSPORT-INIT
*/
Mstro__Pool__InitiateTransfer *transport_init;
/*
** for TRANSPORT-TICKET
*/
Mstro__Pool__TransferTicket *transport_ticket;
/*
** for TRANSFER-COMPLETED
*/
Mstro__Pool__TransferCompleted *transfer_completed;
/*
** for JOIN
*/
Mstro__Pool__Join *join;
/*
** for WELCOME
*/
Mstro__Pool__Welcome *welcome;
/*
** for LEAVE
*/
Mstro__Pool__Leave *leave;
/*
** for BYE
*/
Mstro__Pool__Bye *bye; /*
** for SUBSCRIBE
*/
Mstro__Pool__Subscribe *subscribe;
/*
** for UNSUSBSCIBE
*/
/*
** for pool checkpoint starting
*/
Mstro__Pool__Unsubscribe *unsubscribe;
};
};
#define MSTRO__POOL__EVENT__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__event__descriptor) \
, NULL, 0, MSTRO__POOL__EVENT_KIND__INVALID_EVENT, NULL, (char *)protobuf_c_empty_string, MSTRO__POOL__EVENT__PAYLOAD__NOT_SET, {0} }
struct _Mstro__Pool__EventAck
{
ProtobufCMessage base;
/*
**< the (workflow-unique) event id that is acknowledged
*/
uint64_t serial;
};
#define MSTRO__POOL__EVENT_ACK__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__event_ack__descriptor) \
, 0 }
/*
** Configure messages from pool manager to apps
*/
struct _Mstro__Pool__Configure
{
ProtobufCMessage base;
};
#define MSTRO__POOL__CONFIGURE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__configure__descriptor) \
}
/*
** advise that a CDO which has been required can now be demanded cheaply
*/
struct _Mstro__Pool__CDODemandable
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__CDODEMANDABLE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__cdodemandable__descriptor) \
, NULL }
/*
** advise that a CDO which has been offered can now be withdrawn cheaply
*/
struct _Mstro__Pool__CDOWithdrawable
{
ProtobufCMessage base;
Mstro__Pool__UUID *cdoid;
};
#define MSTRO__POOL__CDOWITHDRAWABLE__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__cdowithdrawable__descriptor) \
, NULL }
/* ** Log to a central destination by sending log info to the pool manager.
**
** This may be a VSM message. If so, it will use the dedicated LOG
** channel.
*/
struct _Mstro__Pool__Log
{
ProtobufCMessage base;
};
#define MSTRO__POOL__LOG__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__log__descriptor) \
}
/*
** Group construction by querying pool
*/
struct _Mstro__Pool__Query
{
ProtobufCMessage base;
/*
**< the (app-local) serial for the query
*/
uint64_t serial;
/*
**< a selector
*/
Mstro__Pool__CDOSelector *selector;
};
#define MSTRO__POOL__QUERY__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__query__descriptor) \
, 0, NULL }
/*
** Query result handle: a UUID that is suitable to refer to the group later
**
** The usage is very similar to DECLARE
*/
struct _Mstro__Pool__QueryRes
{
ProtobufCMessage base;
uint64_t serial;
Mstro__Pool__UUID *groupid;
uint64_t channel;
};
#define MSTRO__POOL__QUERY_RES__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__query_res__descriptor) \
, 0, NULL, 0 }
/*
** Message options type
*/
struct _Mstro__Pool__MstroMsg__Opts
{
ProtobufCMessage base;
/*
** will message be followed by VSM messages?
*/
Mstro__Pool__VSMAnnouncement *vsm_data;
};
#define MSTRO__POOL__MSTRO_MSG__OPTS__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__mstro_msg__opts__descriptor) \
, NULL }
typedef enum {
MSTRO__POOL__MSTRO_MSG__MSG__NOT_SET = 0,
MSTRO__POOL__MSTRO_MSG__MSG_DECLARE = 4, MSTRO__POOL__MSTRO_MSG__MSG_DECLARE_ACK = 5,
MSTRO__POOL__MSTRO_MSG__MSG_SEAL = 6,
MSTRO__POOL__MSTRO_MSG__MSG_SEAL_GROUP = 7,
MSTRO__POOL__MSTRO_MSG__MSG_OFFER = 8,
MSTRO__POOL__MSTRO_MSG__MSG_REQUIRE = 9,
MSTRO__POOL__MSTRO_MSG__MSG_RETRACT = 10,
MSTRO__POOL__MSTRO_MSG__MSG_DEMAND = 12,
MSTRO__POOL__MSTRO_MSG__MSG_WITHDRAW = 13,
MSTRO__POOL__MSTRO_MSG__MSG_DISPOSE = 15,
MSTRO__POOL__MSTRO_MSG__MSG_ACK = 16,
MSTRO__POOL__MSTRO_MSG__MSG_INITIATE_TRANSFER = 17,
MSTRO__POOL__MSTRO_MSG__MSG_TRANSFER_TICKET = 18,
MSTRO__POOL__MSTRO_MSG__MSG_TRANSFER_COMPLETED = 19,
MSTRO__POOL__MSTRO_MSG__MSG_JOIN = 20,
MSTRO__POOL__MSTRO_MSG__MSG_WELCOME = 21,
MSTRO__POOL__MSTRO_MSG__MSG_LEAVE = 22,
MSTRO__POOL__MSTRO_MSG__MSG_BYE = 23,
MSTRO__POOL__MSTRO_MSG__MSG_SUBSCRIBE = 24,
MSTRO__POOL__MSTRO_MSG__MSG_SUBSCRIBE_ACK = 25,
MSTRO__POOL__MSTRO_MSG__MSG_UNSUBSCRIBE = 26,
MSTRO__POOL__MSTRO_MSG__MSG_EVENT = 28,
MSTRO__POOL__MSTRO_MSG__MSG_EVENT_ACK = 29,
MSTRO__POOL__MSTRO_MSG__MSG_LOG = 30,
MSTRO__POOL__MSTRO_MSG__MSG_DEMAND_ATTR = 31,
MSTRO__POOL__MSTRO_MSG__MSG_DEMAND_ATTR_RES = 32,
MSTRO__POOL__MSTRO_MSG__MSG_QUERY = 33,
MSTRO__POOL__MSTRO_MSG__MSG_QUERY_RES = 34,
MSTRO__POOL__MSTRO_MSG__MSG_DETACH = 35,
MSTRO__POOL__MSTRO_MSG__MSG_RESOLVE = 36,
MSTRO__POOL__MSTRO_MSG__MSG_RESOLVE_REPLY = 37
PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(MSTRO__POOL__MSTRO_MSG__MSG)
} Mstro__Pool__MstroMsg__MsgCase;
struct _Mstro__Pool__MstroMsg
{
ProtobufCMessage base;
/*
** the app token received during the JOIN/WELCOME handshake
*/
Mstro__Pool__Apptoken *token;
/*
** Message options
*/
Mstro__Pool__MstroMsg__Opts *opts;
/*
** inline payload. FIXME: document size constraints
*/
/*
* repeated fields should have a protobuf tag < 16
*/
size_t n_data;
ProtobufCBinaryData *data;
Mstro__Pool__MstroMsg__MsgCase msg_case;
union {
/*
* frequent messages should get indices <=15
*/
/*
** a DECLARE
*/
Mstro__Pool__Declare *declare;
Mstro__Pool__DeclareAck *declare_ack;
Mstro__Pool__Seal *seal;
Mstro__Pool__SealGroup *seal_group;
Mstro__Pool__Offer *offer;
Mstro__Pool__Require *require;
/*
* possibly infrequent
*/
Mstro__Pool__Retract *retract; Mstro__Pool__Demand *demand;
Mstro__Pool__Withdraw *withdraw;
Mstro__Pool__Dispose *dispose;
/*
** ack for OFFER/REQUIRE/RETRACT/WITHDRAW
*/
Mstro__Pool__PoolOpAck *ack;
/*
* transport
*/
Mstro__Pool__InitiateTransfer *initiate_transfer;
Mstro__Pool__TransferTicket *transfer_ticket;
/*
* Does this message convey more semantics than "ack" above?
*/
Mstro__Pool__TransferCompleted *transfer_completed;
/*
* infrequent messages
*/
Mstro__Pool__Join *join;
Mstro__Pool__Welcome *welcome;
Mstro__Pool__Leave *leave;
Mstro__Pool__Bye *bye;
Mstro__Pool__Subscribe *subscribe;
Mstro__Pool__SubscribeAck *subscribe_ack;
Mstro__Pool__Unsubscribe *unsubscribe;
/*
* Getinfo get_info = 27;
*/
Mstro__Pool__Event *event;
Mstro__Pool__EventAck *event_ack;
Mstro__Pool__Log *log;
Mstro__Pool__DemandAttr *demand_attr;
Mstro__Pool__DemandAttrRes *demand_attr_res;
Mstro__Pool__Query *query;
Mstro__Pool__QueryRes *query_res;
/*
* potentially useful: emergency detach
*/
Mstro__Pool__EmergencyDetach *detach;
/*
** Resolve opaque data
*/
Mstro__Pool__Resolve *resolve;
/*
** Resolve opaque data
*/
Mstro__Pool__ResolveReply *resolve_reply;
};
};
#define MSTRO__POOL__MSTRO_MSG__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__mstro_msg__descriptor) \
, NULL, NULL, 0,NULL, MSTRO__POOL__MSTRO_MSG__MSG__NOT_SET, {0} }
struct _Mstro__Pool__FragmentedMsg
{
ProtobufCMessage base;
/*
** more VSM data coming up?
*/
Mstro__Pool__VSMAnnouncement *vsm_data;
/*
** Payload
**@} (end of group MSTRO_Pool_Protocol)
**@} (end of addtogroup MSTRO_Core)
*/
size_t n_data;
ProtobufCBinaryData *data;
};#define MSTRO__POOL__FRAGMENTED_MSG__INIT \
{ PROTOBUF_C_MESSAGE_INIT (&mstro__pool__fragmented_msg__descriptor) \
, NULL, 0,NULL }
/* Mstro__Pool__UUID methods */
void mstro__pool__uuid__init
(Mstro__Pool__UUID *message);
size_t mstro__pool__uuid__get_packed_size
(const Mstro__Pool__UUID *message);
size_t mstro__pool__uuid__pack
(const Mstro__Pool__UUID *message,
uint8_t *out);
size_t mstro__pool__uuid__pack_to_buffer
(const Mstro__Pool__UUID *message,
ProtobufCBuffer *buffer);
Mstro__Pool__UUID *
mstro__pool__uuid__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__uuid__free_unpacked
(Mstro__Pool__UUID *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Appid methods */
void mstro__pool__appid__init
(Mstro__Pool__Appid *message);
size_t mstro__pool__appid__get_packed_size
(const Mstro__Pool__Appid *message);
size_t mstro__pool__appid__pack
(const Mstro__Pool__Appid *message,
uint8_t *out);
size_t mstro__pool__appid__pack_to_buffer
(const Mstro__Pool__Appid *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Appid *
mstro__pool__appid__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__appid__free_unpacked
(Mstro__Pool__Appid *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Apptoken methods */
void mstro__pool__apptoken__init
(Mstro__Pool__Apptoken *message);
size_t mstro__pool__apptoken__get_packed_size
(const Mstro__Pool__Apptoken *message);
size_t mstro__pool__apptoken__pack
(const Mstro__Pool__Apptoken *message,
uint8_t *out);
size_t mstro__pool__apptoken__pack_to_buffer
(const Mstro__Pool__Apptoken *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Apptoken *
mstro__pool__apptoken__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__apptoken__free_unpacked
(Mstro__Pool__Apptoken *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__VSMAnnouncement methods */
void mstro__pool__vsmannouncement__init
(Mstro__Pool__VSMAnnouncement *message);
size_t mstro__pool__vsmannouncement__get_packed_size
(const Mstro__Pool__VSMAnnouncement *message);
size_t mstro__pool__vsmannouncement__pack
(const Mstro__Pool__VSMAnnouncement *message,
uint8_t *out);size_t mstro__pool__vsmannouncement__pack_to_buffer
(const Mstro__Pool__VSMAnnouncement *message,
ProtobufCBuffer *buffer);
Mstro__Pool__VSMAnnouncement *
mstro__pool__vsmannouncement__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__vsmannouncement__free_unpacked
(Mstro__Pool__VSMAnnouncement *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Join methods */
void mstro__pool__join__init
(Mstro__Pool__Join *message);
size_t mstro__pool__join__get_packed_size
(const Mstro__Pool__Join *message);
size_t mstro__pool__join__pack
(const Mstro__Pool__Join *message,
uint8_t *out);
size_t mstro__pool__join__pack_to_buffer
(const Mstro__Pool__Join *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Join *
mstro__pool__join__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__join__free_unpacked
(Mstro__Pool__Join *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Welcome methods */
void mstro__pool__welcome__init
(Mstro__Pool__Welcome *message);
size_t mstro__pool__welcome__get_packed_size
(const Mstro__Pool__Welcome *message);
size_t mstro__pool__welcome__pack
(const Mstro__Pool__Welcome *message,
uint8_t *out);
size_t mstro__pool__welcome__pack_to_buffer
(const Mstro__Pool__Welcome *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Welcome *
mstro__pool__welcome__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__welcome__free_unpacked
(Mstro__Pool__Welcome *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Leave methods */
void mstro__pool__leave__init
(Mstro__Pool__Leave *message);
size_t mstro__pool__leave__get_packed_size
(const Mstro__Pool__Leave *message);
size_t mstro__pool__leave__pack
(const Mstro__Pool__Leave *message,
uint8_t *out);
size_t mstro__pool__leave__pack_to_buffer
(const Mstro__Pool__Leave *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Leave *
mstro__pool__leave__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__leave__free_unpacked
(Mstro__Pool__Leave *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__EmergencyDetach methods */
void mstro__pool__emergency_detach__init (Mstro__Pool__EmergencyDetach *message);
size_t mstro__pool__emergency_detach__get_packed_size
(const Mstro__Pool__EmergencyDetach *message);
size_t mstro__pool__emergency_detach__pack
(const Mstro__Pool__EmergencyDetach *message,
uint8_t *out);
size_t mstro__pool__emergency_detach__pack_to_buffer
(const Mstro__Pool__EmergencyDetach *message,
ProtobufCBuffer *buffer);
Mstro__Pool__EmergencyDetach *
mstro__pool__emergency_detach__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__emergency_detach__free_unpacked
(Mstro__Pool__EmergencyDetach *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Resolve methods */
void mstro__pool__resolve__init
(Mstro__Pool__Resolve *message);
size_t mstro__pool__resolve__get_packed_size
(const Mstro__Pool__Resolve *message);
size_t mstro__pool__resolve__pack
(const Mstro__Pool__Resolve *message,
uint8_t *out);
size_t mstro__pool__resolve__pack_to_buffer
(const Mstro__Pool__Resolve *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Resolve *
mstro__pool__resolve__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__resolve__free_unpacked
(Mstro__Pool__Resolve *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__ResolveReply methods */
void mstro__pool__resolve_reply__init
(Mstro__Pool__ResolveReply *message);
size_t mstro__pool__resolve_reply__get_packed_size
(const Mstro__Pool__ResolveReply *message);
size_t mstro__pool__resolve_reply__pack
(const Mstro__Pool__ResolveReply *message,
uint8_t *out);
size_t mstro__pool__resolve_reply__pack_to_buffer
(const Mstro__Pool__ResolveReply *message,
ProtobufCBuffer *buffer);
Mstro__Pool__ResolveReply *
mstro__pool__resolve_reply__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__resolve_reply__free_unpacked
(Mstro__Pool__ResolveReply *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Bye methods */
void mstro__pool__bye__init
(Mstro__Pool__Bye *message);
size_t mstro__pool__bye__get_packed_size
(const Mstro__Pool__Bye *message);
size_t mstro__pool__bye__pack
(const Mstro__Pool__Bye *message,
uint8_t *out);
size_t mstro__pool__bye__pack_to_buffer
(const Mstro__Pool__Bye *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Bye *
mstro__pool__bye__unpack
(ProtobufCAllocator *allocator,
size_t len, const uint8_t *data);
void mstro__pool__bye__free_unpacked
(Mstro__Pool__Bye *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Declare methods */
void mstro__pool__declare__init
(Mstro__Pool__Declare *message);
size_t mstro__pool__declare__get_packed_size
(const Mstro__Pool__Declare *message);
size_t mstro__pool__declare__pack
(const Mstro__Pool__Declare *message,
uint8_t *out);
size_t mstro__pool__declare__pack_to_buffer
(const Mstro__Pool__Declare *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Declare *
mstro__pool__declare__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__declare__free_unpacked
(Mstro__Pool__Declare *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__DeclareAck methods */
void mstro__pool__declare_ack__init
(Mstro__Pool__DeclareAck *message);
size_t mstro__pool__declare_ack__get_packed_size
(const Mstro__Pool__DeclareAck *message);
size_t mstro__pool__declare_ack__pack
(const Mstro__Pool__DeclareAck *message,
uint8_t *out);
size_t mstro__pool__declare_ack__pack_to_buffer
(const Mstro__Pool__DeclareAck *message,
ProtobufCBuffer *buffer);
Mstro__Pool__DeclareAck *
mstro__pool__declare_ack__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__declare_ack__free_unpacked
(Mstro__Pool__DeclareAck *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Timestamp methods */
void mstro__pool__timestamp__init
(Mstro__Pool__Timestamp *message);
size_t mstro__pool__timestamp__get_packed_size
(const Mstro__Pool__Timestamp *message);
size_t mstro__pool__timestamp__pack
(const Mstro__Pool__Timestamp *message,
uint8_t *out);
size_t mstro__pool__timestamp__pack_to_buffer
(const Mstro__Pool__Timestamp *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Timestamp *
mstro__pool__timestamp__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__timestamp__free_unpacked
(Mstro__Pool__Timestamp *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__GroupMembers methods */
void mstro__pool__group_members__init
(Mstro__Pool__GroupMembers *message);
size_t mstro__pool__group_members__get_packed_size
(const Mstro__Pool__GroupMembers *message);
size_t mstro__pool__group_members__pack
(const Mstro__Pool__GroupMembers *message,
uint8_t *out);
size_t mstro__pool__group_members__pack_to_buffer (const Mstro__Pool__GroupMembers *message,
ProtobufCBuffer *buffer);
Mstro__Pool__GroupMembers *
mstro__pool__group_members__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__group_members__free_unpacked
(Mstro__Pool__GroupMembers *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__AVal methods */
void mstro__pool__aval__init
(Mstro__Pool__AVal *message);
size_t mstro__pool__aval__get_packed_size
(const Mstro__Pool__AVal *message);
size_t mstro__pool__aval__pack
(const Mstro__Pool__AVal *message,
uint8_t *out);
size_t mstro__pool__aval__pack_to_buffer
(const Mstro__Pool__AVal *message,
ProtobufCBuffer *buffer);
Mstro__Pool__AVal *
mstro__pool__aval__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__aval__free_unpacked
(Mstro__Pool__AVal *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__KvEntry methods */
void mstro__pool__kv_entry__init
(Mstro__Pool__KvEntry *message);
size_t mstro__pool__kv_entry__get_packed_size
(const Mstro__Pool__KvEntry *message);
size_t mstro__pool__kv_entry__pack
(const Mstro__Pool__KvEntry *message,
uint8_t *out);
size_t mstro__pool__kv_entry__pack_to_buffer
(const Mstro__Pool__KvEntry *message,
ProtobufCBuffer *buffer);
Mstro__Pool__KvEntry *
mstro__pool__kv_entry__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__kv_entry__free_unpacked
(Mstro__Pool__KvEntry *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Attributes__Map methods */
void mstro__pool__attributes__map__init
(Mstro__Pool__Attributes__Map *message);
/* Mstro__Pool__Attributes methods */
void mstro__pool__attributes__init
(Mstro__Pool__Attributes *message);
size_t mstro__pool__attributes__get_packed_size
(const Mstro__Pool__Attributes *message);
size_t mstro__pool__attributes__pack
(const Mstro__Pool__Attributes *message,
uint8_t *out);
size_t mstro__pool__attributes__pack_to_buffer
(const Mstro__Pool__Attributes *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Attributes *
mstro__pool__attributes__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__attributes__free_unpacked
(Mstro__Pool__Attributes *message,
ProtobufCAllocator *allocator);/* Mstro__Pool__Seal methods */
void mstro__pool__seal__init
(Mstro__Pool__Seal *message);
size_t mstro__pool__seal__get_packed_size
(const Mstro__Pool__Seal *message);
size_t mstro__pool__seal__pack
(const Mstro__Pool__Seal *message,
uint8_t *out);
size_t mstro__pool__seal__pack_to_buffer
(const Mstro__Pool__Seal *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Seal *
mstro__pool__seal__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__seal__free_unpacked
(Mstro__Pool__Seal *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__SealGroup methods */
void mstro__pool__seal_group__init
(Mstro__Pool__SealGroup *message);
size_t mstro__pool__seal_group__get_packed_size
(const Mstro__Pool__SealGroup *message);
size_t mstro__pool__seal_group__pack
(const Mstro__Pool__SealGroup *message,
uint8_t *out);
size_t mstro__pool__seal_group__pack_to_buffer
(const Mstro__Pool__SealGroup *message,
ProtobufCBuffer *buffer);
Mstro__Pool__SealGroup *
mstro__pool__seal_group__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__seal_group__free_unpacked
(Mstro__Pool__SealGroup *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Offer methods */
void mstro__pool__offer__init
(Mstro__Pool__Offer *message);
size_t mstro__pool__offer__get_packed_size
(const Mstro__Pool__Offer *message);
size_t mstro__pool__offer__pack
(const Mstro__Pool__Offer *message,
uint8_t *out);
size_t mstro__pool__offer__pack_to_buffer
(const Mstro__Pool__Offer *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Offer *
mstro__pool__offer__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__offer__free_unpacked
(Mstro__Pool__Offer *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Withdraw methods */
void mstro__pool__withdraw__init
(Mstro__Pool__Withdraw *message);
size_t mstro__pool__withdraw__get_packed_size
(const Mstro__Pool__Withdraw *message);
size_t mstro__pool__withdraw__pack
(const Mstro__Pool__Withdraw *message,
uint8_t *out);
size_t mstro__pool__withdraw__pack_to_buffer
(const Mstro__Pool__Withdraw *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Withdraw *
mstro__pool__withdraw__unpack (ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__withdraw__free_unpacked
(Mstro__Pool__Withdraw *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Dispose methods */
void mstro__pool__dispose__init
(Mstro__Pool__Dispose *message);
size_t mstro__pool__dispose__get_packed_size
(const Mstro__Pool__Dispose *message);
size_t mstro__pool__dispose__pack
(const Mstro__Pool__Dispose *message,
uint8_t *out);
size_t mstro__pool__dispose__pack_to_buffer
(const Mstro__Pool__Dispose *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Dispose *
mstro__pool__dispose__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__dispose__free_unpacked
(Mstro__Pool__Dispose *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Require methods */
void mstro__pool__require__init
(Mstro__Pool__Require *message);
size_t mstro__pool__require__get_packed_size
(const Mstro__Pool__Require *message);
size_t mstro__pool__require__pack
(const Mstro__Pool__Require *message,
uint8_t *out);
size_t mstro__pool__require__pack_to_buffer
(const Mstro__Pool__Require *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Require *
mstro__pool__require__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__require__free_unpacked
(Mstro__Pool__Require *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Retract methods */
void mstro__pool__retract__init
(Mstro__Pool__Retract *message);
size_t mstro__pool__retract__get_packed_size
(const Mstro__Pool__Retract *message);
size_t mstro__pool__retract__pack
(const Mstro__Pool__Retract *message,
uint8_t *out);
size_t mstro__pool__retract__pack_to_buffer
(const Mstro__Pool__Retract *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Retract *
mstro__pool__retract__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__retract__free_unpacked
(Mstro__Pool__Retract *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__PoolOpAck methods */
void mstro__pool__pool_op_ack__init
(Mstro__Pool__PoolOpAck *message);
size_t mstro__pool__pool_op_ack__get_packed_size
(const Mstro__Pool__PoolOpAck *message);
size_t mstro__pool__pool_op_ack__pack
(const Mstro__Pool__PoolOpAck *message, uint8_t *out);
size_t mstro__pool__pool_op_ack__pack_to_buffer
(const Mstro__Pool__PoolOpAck *message,
ProtobufCBuffer *buffer);
Mstro__Pool__PoolOpAck *
mstro__pool__pool_op_ack__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__pool_op_ack__free_unpacked
(Mstro__Pool__PoolOpAck *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Demand methods */
void mstro__pool__demand__init
(Mstro__Pool__Demand *message);
size_t mstro__pool__demand__get_packed_size
(const Mstro__Pool__Demand *message);
size_t mstro__pool__demand__pack
(const Mstro__Pool__Demand *message,
uint8_t *out);
size_t mstro__pool__demand__pack_to_buffer
(const Mstro__Pool__Demand *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Demand *
mstro__pool__demand__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__demand__free_unpacked
(Mstro__Pool__Demand *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__DemandAttr methods */
void mstro__pool__demand_attr__init
(Mstro__Pool__DemandAttr *message);
size_t mstro__pool__demand_attr__get_packed_size
(const Mstro__Pool__DemandAttr *message);
size_t mstro__pool__demand_attr__pack
(const Mstro__Pool__DemandAttr *message,
uint8_t *out);
size_t mstro__pool__demand_attr__pack_to_buffer
(const Mstro__Pool__DemandAttr *message,
ProtobufCBuffer *buffer);
Mstro__Pool__DemandAttr *
mstro__pool__demand_attr__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__demand_attr__free_unpacked
(Mstro__Pool__DemandAttr *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__DemandAttrRes methods */
void mstro__pool__demand_attr_res__init
(Mstro__Pool__DemandAttrRes *message);
size_t mstro__pool__demand_attr_res__get_packed_size
(const Mstro__Pool__DemandAttrRes *message);
size_t mstro__pool__demand_attr_res__pack
(const Mstro__Pool__DemandAttrRes *message,
uint8_t *out);
size_t mstro__pool__demand_attr_res__pack_to_buffer
(const Mstro__Pool__DemandAttrRes *message,
ProtobufCBuffer *buffer);
Mstro__Pool__DemandAttrRes *
mstro__pool__demand_attr_res__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__demand_attr_res__free_unpacked
(Mstro__Pool__DemandAttrRes *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__TransportMethods methods */void mstro__pool__transport_methods__init
(Mstro__Pool__TransportMethods *message);
size_t mstro__pool__transport_methods__get_packed_size
(const Mstro__Pool__TransportMethods *message);
size_t mstro__pool__transport_methods__pack
(const Mstro__Pool__TransportMethods *message,
uint8_t *out);
size_t mstro__pool__transport_methods__pack_to_buffer
(const Mstro__Pool__TransportMethods *message,
ProtobufCBuffer *buffer);
Mstro__Pool__TransportMethods *
mstro__pool__transport_methods__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__transport_methods__free_unpacked
(Mstro__Pool__TransportMethods *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__InitiateTransfer methods */
void mstro__pool__initiate_transfer__init
(Mstro__Pool__InitiateTransfer *message);
size_t mstro__pool__initiate_transfer__get_packed_size
(const Mstro__Pool__InitiateTransfer *message);
size_t mstro__pool__initiate_transfer__pack
(const Mstro__Pool__InitiateTransfer *message,
uint8_t *out);
size_t mstro__pool__initiate_transfer__pack_to_buffer
(const Mstro__Pool__InitiateTransfer *message,
ProtobufCBuffer *buffer);
Mstro__Pool__InitiateTransfer *
mstro__pool__initiate_transfer__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__initiate_transfer__free_unpacked
(Mstro__Pool__InitiateTransfer *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__TransferTicketGFS methods */
void mstro__pool__transfer_ticket_gfs__init
(Mstro__Pool__TransferTicketGFS *message);
size_t mstro__pool__transfer_ticket_gfs__get_packed_size
(const Mstro__Pool__TransferTicketGFS *message);
size_t mstro__pool__transfer_ticket_gfs__pack
(const Mstro__Pool__TransferTicketGFS *message,
uint8_t *out);
size_t mstro__pool__transfer_ticket_gfs__pack_to_buffer
(const Mstro__Pool__TransferTicketGFS *message,
ProtobufCBuffer *buffer);
Mstro__Pool__TransferTicketGFS *
mstro__pool__transfer_ticket_gfs__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__transfer_ticket_gfs__free_unpacked
(Mstro__Pool__TransferTicketGFS *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__TransferTicketUDJ methods */
void mstro__pool__transfer_ticket_udj__init
(Mstro__Pool__TransferTicketUDJ *message);
size_t mstro__pool__transfer_ticket_udj__get_packed_size
(const Mstro__Pool__TransferTicketUDJ *message);
size_t mstro__pool__transfer_ticket_udj__pack
(const Mstro__Pool__TransferTicketUDJ *message,
uint8_t *out);
size_t mstro__pool__transfer_ticket_udj__pack_to_buffer
(const Mstro__Pool__TransferTicketUDJ *message,
ProtobufCBuffer *buffer);
Mstro__Pool__TransferTicketUDJ *
mstro__pool__transfer_ticket_udj__unpack
(ProtobufCAllocator *allocator, size_t len,
const uint8_t *data);
void mstro__pool__transfer_ticket_udj__free_unpacked
(Mstro__Pool__TransferTicketUDJ *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__TransferTicketMIO methods */
void mstro__pool__transfer_ticket_mio__init
(Mstro__Pool__TransferTicketMIO *message);
size_t mstro__pool__transfer_ticket_mio__get_packed_size
(const Mstro__Pool__TransferTicketMIO *message);
size_t mstro__pool__transfer_ticket_mio__pack
(const Mstro__Pool__TransferTicketMIO *message,
uint8_t *out);
size_t mstro__pool__transfer_ticket_mio__pack_to_buffer
(const Mstro__Pool__TransferTicketMIO *message,
ProtobufCBuffer *buffer);
Mstro__Pool__TransferTicketMIO *
mstro__pool__transfer_ticket_mio__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__transfer_ticket_mio__free_unpacked
(Mstro__Pool__TransferTicketMIO *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__RDMAHandle methods */
void mstro__pool__rdmahandle__init
(Mstro__Pool__RDMAHandle *message);
size_t mstro__pool__rdmahandle__get_packed_size
(const Mstro__Pool__RDMAHandle *message);
size_t mstro__pool__rdmahandle__pack
(const Mstro__Pool__RDMAHandle *message,
uint8_t *out);
size_t mstro__pool__rdmahandle__pack_to_buffer
(const Mstro__Pool__RDMAHandle *message,
ProtobufCBuffer *buffer);
Mstro__Pool__RDMAHandle *
mstro__pool__rdmahandle__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__rdmahandle__free_unpacked
(Mstro__Pool__RDMAHandle *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__TransferTicketOFI methods */
void mstro__pool__transfer_ticket_ofi__init
(Mstro__Pool__TransferTicketOFI *message);
size_t mstro__pool__transfer_ticket_ofi__get_packed_size
(const Mstro__Pool__TransferTicketOFI *message);
size_t mstro__pool__transfer_ticket_ofi__pack
(const Mstro__Pool__TransferTicketOFI *message,
uint8_t *out);
size_t mstro__pool__transfer_ticket_ofi__pack_to_buffer
(const Mstro__Pool__TransferTicketOFI *message,
ProtobufCBuffer *buffer);
Mstro__Pool__TransferTicketOFI *
mstro__pool__transfer_ticket_ofi__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__transfer_ticket_ofi__free_unpacked
(Mstro__Pool__TransferTicketOFI *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__TransferTicket methods */
void mstro__pool__transfer_ticket__init
(Mstro__Pool__TransferTicket *message);
size_t mstro__pool__transfer_ticket__get_packed_size
(const Mstro__Pool__TransferTicket *message);
size_t mstro__pool__transfer_ticket__pack
(const Mstro__Pool__TransferTicket *message,
uint8_t *out);size_t mstro__pool__transfer_ticket__pack_to_buffer
(const Mstro__Pool__TransferTicket *message,
ProtobufCBuffer *buffer);
Mstro__Pool__TransferTicket *
mstro__pool__transfer_ticket__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__transfer_ticket__free_unpacked
(Mstro__Pool__TransferTicket *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__TransferCompleted methods */
void mstro__pool__transfer_completed__init
(Mstro__Pool__TransferCompleted *message);
size_t mstro__pool__transfer_completed__get_packed_size
(const Mstro__Pool__TransferCompleted *message);
size_t mstro__pool__transfer_completed__pack
(const Mstro__Pool__TransferCompleted *message,
uint8_t *out);
size_t mstro__pool__transfer_completed__pack_to_buffer
(const Mstro__Pool__TransferCompleted *message,
ProtobufCBuffer *buffer);
Mstro__Pool__TransferCompleted *
mstro__pool__transfer_completed__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__transfer_completed__free_unpacked
(Mstro__Pool__TransferCompleted *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__CDOSelector methods */
void mstro__pool__cdoselector__init
(Mstro__Pool__CDOSelector *message);
size_t mstro__pool__cdoselector__get_packed_size
(const Mstro__Pool__CDOSelector *message);
size_t mstro__pool__cdoselector__pack
(const Mstro__Pool__CDOSelector *message,
uint8_t *out);
size_t mstro__pool__cdoselector__pack_to_buffer
(const Mstro__Pool__CDOSelector *message,
ProtobufCBuffer *buffer);
Mstro__Pool__CDOSelector *
mstro__pool__cdoselector__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__cdoselector__free_unpacked
(Mstro__Pool__CDOSelector *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__SubscriptionHandle methods */
void mstro__pool__subscription_handle__init
(Mstro__Pool__SubscriptionHandle *message);
size_t mstro__pool__subscription_handle__get_packed_size
(const Mstro__Pool__SubscriptionHandle *message);
size_t mstro__pool__subscription_handle__pack
(const Mstro__Pool__SubscriptionHandle *message,
uint8_t *out);
size_t mstro__pool__subscription_handle__pack_to_buffer
(const Mstro__Pool__SubscriptionHandle *message,
ProtobufCBuffer *buffer);
Mstro__Pool__SubscriptionHandle *
mstro__pool__subscription_handle__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__subscription_handle__free_unpacked
(Mstro__Pool__SubscriptionHandle *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Subscribe methods */
void mstro__pool__subscribe__init (Mstro__Pool__Subscribe *message);
size_t mstro__pool__subscribe__get_packed_size
(const Mstro__Pool__Subscribe *message);
size_t mstro__pool__subscribe__pack
(const Mstro__Pool__Subscribe *message,
uint8_t *out);
size_t mstro__pool__subscribe__pack_to_buffer
(const Mstro__Pool__Subscribe *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Subscribe *
mstro__pool__subscribe__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__subscribe__free_unpacked
(Mstro__Pool__Subscribe *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__SubscribeAck methods */
void mstro__pool__subscribe_ack__init
(Mstro__Pool__SubscribeAck *message);
size_t mstro__pool__subscribe_ack__get_packed_size
(const Mstro__Pool__SubscribeAck *message);
size_t mstro__pool__subscribe_ack__pack
(const Mstro__Pool__SubscribeAck *message,
uint8_t *out);
size_t mstro__pool__subscribe_ack__pack_to_buffer
(const Mstro__Pool__SubscribeAck *message,
ProtobufCBuffer *buffer);
Mstro__Pool__SubscribeAck *
mstro__pool__subscribe_ack__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__subscribe_ack__free_unpacked
(Mstro__Pool__SubscribeAck *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Unsubscribe methods */
void mstro__pool__unsubscribe__init
(Mstro__Pool__Unsubscribe *message);
size_t mstro__pool__unsubscribe__get_packed_size
(const Mstro__Pool__Unsubscribe *message);
size_t mstro__pool__unsubscribe__pack
(const Mstro__Pool__Unsubscribe *message,
uint8_t *out);
size_t mstro__pool__unsubscribe__pack_to_buffer
(const Mstro__Pool__Unsubscribe *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Unsubscribe *
mstro__pool__unsubscribe__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__unsubscribe__free_unpacked
(Mstro__Pool__Unsubscribe *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Event methods */
void mstro__pool__event__init
(Mstro__Pool__Event *message);
size_t mstro__pool__event__get_packed_size
(const Mstro__Pool__Event *message);
size_t mstro__pool__event__pack
(const Mstro__Pool__Event *message,
uint8_t *out);
size_t mstro__pool__event__pack_to_buffer
(const Mstro__Pool__Event *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Event *
mstro__pool__event__unpack
(ProtobufCAllocator *allocator,
size_t len, const uint8_t *data);
void mstro__pool__event__free_unpacked
(Mstro__Pool__Event *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__EventAck methods */
void mstro__pool__event_ack__init
(Mstro__Pool__EventAck *message);
size_t mstro__pool__event_ack__get_packed_size
(const Mstro__Pool__EventAck *message);
size_t mstro__pool__event_ack__pack
(const Mstro__Pool__EventAck *message,
uint8_t *out);
size_t mstro__pool__event_ack__pack_to_buffer
(const Mstro__Pool__EventAck *message,
ProtobufCBuffer *buffer);
Mstro__Pool__EventAck *
mstro__pool__event_ack__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__event_ack__free_unpacked
(Mstro__Pool__EventAck *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Configure methods */
void mstro__pool__configure__init
(Mstro__Pool__Configure *message);
size_t mstro__pool__configure__get_packed_size
(const Mstro__Pool__Configure *message);
size_t mstro__pool__configure__pack
(const Mstro__Pool__Configure *message,
uint8_t *out);
size_t mstro__pool__configure__pack_to_buffer
(const Mstro__Pool__Configure *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Configure *
mstro__pool__configure__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__configure__free_unpacked
(Mstro__Pool__Configure *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__CDODemandable methods */
void mstro__pool__cdodemandable__init
(Mstro__Pool__CDODemandable *message);
size_t mstro__pool__cdodemandable__get_packed_size
(const Mstro__Pool__CDODemandable *message);
size_t mstro__pool__cdodemandable__pack
(const Mstro__Pool__CDODemandable *message,
uint8_t *out);
size_t mstro__pool__cdodemandable__pack_to_buffer
(const Mstro__Pool__CDODemandable *message,
ProtobufCBuffer *buffer);
Mstro__Pool__CDODemandable *
mstro__pool__cdodemandable__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__cdodemandable__free_unpacked
(Mstro__Pool__CDODemandable *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__CDOWithdrawable methods */
void mstro__pool__cdowithdrawable__init
(Mstro__Pool__CDOWithdrawable *message);
size_t mstro__pool__cdowithdrawable__get_packed_size
(const Mstro__Pool__CDOWithdrawable *message);
size_t mstro__pool__cdowithdrawable__pack
(const Mstro__Pool__CDOWithdrawable *message,
uint8_t *out);
size_t mstro__pool__cdowithdrawable__pack_to_buffer (const Mstro__Pool__CDOWithdrawable *message,
ProtobufCBuffer *buffer);
Mstro__Pool__CDOWithdrawable *
mstro__pool__cdowithdrawable__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__cdowithdrawable__free_unpacked
(Mstro__Pool__CDOWithdrawable *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Log methods */
void mstro__pool__log__init
(Mstro__Pool__Log *message);
size_t mstro__pool__log__get_packed_size
(const Mstro__Pool__Log *message);
size_t mstro__pool__log__pack
(const Mstro__Pool__Log *message,
uint8_t *out);
size_t mstro__pool__log__pack_to_buffer
(const Mstro__Pool__Log *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Log *
mstro__pool__log__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__log__free_unpacked
(Mstro__Pool__Log *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__Query methods */
void mstro__pool__query__init
(Mstro__Pool__Query *message);
size_t mstro__pool__query__get_packed_size
(const Mstro__Pool__Query *message);
size_t mstro__pool__query__pack
(const Mstro__Pool__Query *message,
uint8_t *out);
size_t mstro__pool__query__pack_to_buffer
(const Mstro__Pool__Query *message,
ProtobufCBuffer *buffer);
Mstro__Pool__Query *
mstro__pool__query__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__query__free_unpacked
(Mstro__Pool__Query *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__QueryRes methods */
void mstro__pool__query_res__init
(Mstro__Pool__QueryRes *message);
size_t mstro__pool__query_res__get_packed_size
(const Mstro__Pool__QueryRes *message);
size_t mstro__pool__query_res__pack
(const Mstro__Pool__QueryRes *message,
uint8_t *out);
size_t mstro__pool__query_res__pack_to_buffer
(const Mstro__Pool__QueryRes *message,
ProtobufCBuffer *buffer);
Mstro__Pool__QueryRes *
mstro__pool__query_res__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__query_res__free_unpacked
(Mstro__Pool__QueryRes *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__MstroMsg__Opts methods */
void mstro__pool__mstro_msg__opts__init
(Mstro__Pool__MstroMsg__Opts *message);/* Mstro__Pool__MstroMsg methods */
void mstro__pool__mstro_msg__init
(Mstro__Pool__MstroMsg *message);
size_t mstro__pool__mstro_msg__get_packed_size
(const Mstro__Pool__MstroMsg *message);
size_t mstro__pool__mstro_msg__pack
(const Mstro__Pool__MstroMsg *message,
uint8_t *out);
size_t mstro__pool__mstro_msg__pack_to_buffer
(const Mstro__Pool__MstroMsg *message,
ProtobufCBuffer *buffer);
Mstro__Pool__MstroMsg *
mstro__pool__mstro_msg__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__mstro_msg__free_unpacked
(Mstro__Pool__MstroMsg *message,
ProtobufCAllocator *allocator);
/* Mstro__Pool__FragmentedMsg methods */
void mstro__pool__fragmented_msg__init
(Mstro__Pool__FragmentedMsg *message);
size_t mstro__pool__fragmented_msg__get_packed_size
(const Mstro__Pool__FragmentedMsg *message);
size_t mstro__pool__fragmented_msg__pack
(const Mstro__Pool__FragmentedMsg *message,
uint8_t *out);
size_t mstro__pool__fragmented_msg__pack_to_buffer
(const Mstro__Pool__FragmentedMsg *message,
ProtobufCBuffer *buffer);
Mstro__Pool__FragmentedMsg *
mstro__pool__fragmented_msg__unpack
(ProtobufCAllocator *allocator,
size_t len,
const uint8_t *data);
void mstro__pool__fragmented_msg__free_unpacked
(Mstro__Pool__FragmentedMsg *message,
ProtobufCAllocator *allocator);
/* --- per-message closures --- */
typedef void (*Mstro__Pool__UUID_Closure)
(const Mstro__Pool__UUID *message,
void *closure_data);
typedef void (*Mstro__Pool__Appid_Closure)
(const Mstro__Pool__Appid *message,
void *closure_data);
typedef void (*Mstro__Pool__Apptoken_Closure)
(const Mstro__Pool__Apptoken *message,
void *closure_data);
typedef void (*Mstro__Pool__VSMAnnouncement_Closure)
(const Mstro__Pool__VSMAnnouncement *message,
void *closure_data);
typedef void (*Mstro__Pool__Join_Closure)
(const Mstro__Pool__Join *message,
void *closure_data);
typedef void (*Mstro__Pool__Welcome_Closure)
(const Mstro__Pool__Welcome *message,
void *closure_data);
typedef void (*Mstro__Pool__Leave_Closure)
(const Mstro__Pool__Leave *message,
void *closure_data);
typedef void (*Mstro__Pool__EmergencyDetach_Closure)
(const Mstro__Pool__EmergencyDetach *message,
void *closure_data);
typedef void (*Mstro__Pool__Resolve_Closure)
(const Mstro__Pool__Resolve *message,
void *closure_data);
typedef void (*Mstro__Pool__ResolveReply_Closure)
(const Mstro__Pool__ResolveReply *message,
void *closure_data);typedef void (*Mstro__Pool__Bye_Closure)
(const Mstro__Pool__Bye *message,
void *closure_data);
typedef void (*Mstro__Pool__Declare_Closure)
(const Mstro__Pool__Declare *message,
void *closure_data);
typedef void (*Mstro__Pool__DeclareAck_Closure)
(const Mstro__Pool__DeclareAck *message,
void *closure_data);
typedef void (*Mstro__Pool__Timestamp_Closure)
(const Mstro__Pool__Timestamp *message,
void *closure_data);
typedef void (*Mstro__Pool__GroupMembers_Closure)
(const Mstro__Pool__GroupMembers *message,
void *closure_data);
typedef void (*Mstro__Pool__AVal_Closure)
(const Mstro__Pool__AVal *message,
void *closure_data);
typedef void (*Mstro__Pool__KvEntry_Closure)
(const Mstro__Pool__KvEntry *message,
void *closure_data);
typedef void (*Mstro__Pool__Attributes__Map_Closure)
(const Mstro__Pool__Attributes__Map *message,
void *closure_data);
typedef void (*Mstro__Pool__Attributes_Closure)
(const Mstro__Pool__Attributes *message,
void *closure_data);
typedef void (*Mstro__Pool__Seal_Closure)
(const Mstro__Pool__Seal *message,
void *closure_data);
typedef void (*Mstro__Pool__SealGroup_Closure)
(const Mstro__Pool__SealGroup *message,
void *closure_data);
typedef void (*Mstro__Pool__Offer_Closure)
(const Mstro__Pool__Offer *message,
void *closure_data);
typedef void (*Mstro__Pool__Withdraw_Closure)
(const Mstro__Pool__Withdraw *message,
void *closure_data);
typedef void (*Mstro__Pool__Dispose_Closure)
(const Mstro__Pool__Dispose *message,
void *closure_data);
typedef void (*Mstro__Pool__Require_Closure)
(const Mstro__Pool__Require *message,
void *closure_data);
typedef void (*Mstro__Pool__Retract_Closure)
(const Mstro__Pool__Retract *message,
void *closure_data);
typedef void (*Mstro__Pool__PoolOpAck_Closure)
(const Mstro__Pool__PoolOpAck *message,
void *closure_data);
typedef void (*Mstro__Pool__Demand_Closure)
(const Mstro__Pool__Demand *message,
void *closure_data);
typedef void (*Mstro__Pool__DemandAttr_Closure)
(const Mstro__Pool__DemandAttr *message,
void *closure_data);
typedef void (*Mstro__Pool__DemandAttrRes_Closure)
(const Mstro__Pool__DemandAttrRes *message,
void *closure_data);
typedef void (*Mstro__Pool__TransportMethods_Closure)
(const Mstro__Pool__TransportMethods *message,
void *closure_data);
typedef void (*Mstro__Pool__InitiateTransfer_Closure)
(const Mstro__Pool__InitiateTransfer *message,
void *closure_data);
typedef void (*Mstro__Pool__TransferTicketGFS_Closure)
(const Mstro__Pool__TransferTicketGFS *message,
void *closure_data);
typedef void (*Mstro__Pool__TransferTicketUDJ_Closure) (const Mstro__Pool__TransferTicketUDJ *message,
void *closure_data);
typedef void (*Mstro__Pool__TransferTicketMIO_Closure)
(const Mstro__Pool__TransferTicketMIO *message,
void *closure_data);
typedef void (*Mstro__Pool__RDMAHandle_Closure)
(const Mstro__Pool__RDMAHandle *message,
void *closure_data);
typedef void (*Mstro__Pool__TransferTicketOFI_Closure)
(const Mstro__Pool__TransferTicketOFI *message,
void *closure_data);
typedef void (*Mstro__Pool__TransferTicket_Closure)
(const Mstro__Pool__TransferTicket *message,
void *closure_data);
typedef void (*Mstro__Pool__TransferCompleted_Closure)
(const Mstro__Pool__TransferCompleted *message,
void *closure_data);
typedef void (*Mstro__Pool__CDOSelector_Closure)
(const Mstro__Pool__CDOSelector *message,
void *closure_data);
typedef void (*Mstro__Pool__SubscriptionHandle_Closure)
(const Mstro__Pool__SubscriptionHandle *message,
void *closure_data);
typedef void (*Mstro__Pool__Subscribe_Closure)
(const Mstro__Pool__Subscribe *message,
void *closure_data);
typedef void (*Mstro__Pool__SubscribeAck_Closure)
(const Mstro__Pool__SubscribeAck *message,
void *closure_data);
typedef void (*Mstro__Pool__Unsubscribe_Closure)
(const Mstro__Pool__Unsubscribe *message,
void *closure_data);
typedef void (*Mstro__Pool__Event_Closure)
(const Mstro__Pool__Event *message,
void *closure_data);
typedef void (*Mstro__Pool__EventAck_Closure)
(const Mstro__Pool__EventAck *message,
void *closure_data);
typedef void (*Mstro__Pool__Configure_Closure)
(const Mstro__Pool__Configure *message,
void *closure_data);
typedef void (*Mstro__Pool__CDODemandable_Closure)
(const Mstro__Pool__CDODemandable *message,
void *closure_data);
typedef void (*Mstro__Pool__CDOWithdrawable_Closure)
(const Mstro__Pool__CDOWithdrawable *message,
void *closure_data);
typedef void (*Mstro__Pool__Log_Closure)
(const Mstro__Pool__Log *message,
void *closure_data);
typedef void (*Mstro__Pool__Query_Closure)
(const Mstro__Pool__Query *message,
void *closure_data);
typedef void (*Mstro__Pool__QueryRes_Closure)
(const Mstro__Pool__QueryRes *message,
void *closure_data);
typedef void (*Mstro__Pool__MstroMsg__Opts_Closure)
(const Mstro__Pool__MstroMsg__Opts *message,
void *closure_data);
typedef void (*Mstro__Pool__MstroMsg_Closure)
(const Mstro__Pool__MstroMsg *message,
void *closure_data);
typedef void (*Mstro__Pool__FragmentedMsg_Closure)
(const Mstro__Pool__FragmentedMsg *message,
void *closure_data);
/* --- services --- */
/* --- descriptors --- */
extern const ProtobufCEnumDescriptor mstro__pool__transport_kind__descriptor;
extern const ProtobufCEnumDescriptor mstro__pool__event_kind__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__uuid__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__appid__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__apptoken__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__vsmannouncement__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__join__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__welcome__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__leave__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__emergency_detach__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__resolve__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__resolve_reply__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__bye__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__declare__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__declare_ack__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__timestamp__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__group_members__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__aval__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__kv_entry__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__attributes__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__attributes__map__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__seal__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__seal_group__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__offer__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__withdraw__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__dispose__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__require__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__retract__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__pool_op_ack__descriptor;
extern const ProtobufCEnumDescriptor mstro__pool__pool_op_ack__pool_op_status__descriptor;
extern const ProtobufCEnumDescriptor mstro__pool__pool_op_ack__pool_op__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__demand__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__demand_attr__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__demand_attr_res__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__transport_methods__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__initiate_transfer__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__transfer_ticket_gfs__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__transfer_ticket_udj__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__transfer_ticket_mio__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__rdmahandle__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__transfer_ticket_ofi__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__transfer_ticket__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__transfer_completed__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__cdoselector__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__subscription_handle__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__subscribe__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__subscribe_ack__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__unsubscribe__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__event__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__event_ack__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__configure__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__cdodemandable__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__cdowithdrawable__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__log__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__query__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__query_res__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__mstro_msg__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__mstro_msg__opts__descriptor;
extern const ProtobufCMessageDescriptor mstro__pool__fragmented_msg__descriptor;
PROTOBUF_C__END_DECLS
#endif /* PROTOBUF_C_mstro_5fpool_2eproto__INCLUDED */