Index: sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/CMakeLists.txt =================================================================== --- sysrepo-7aa2f18d234267403147df92c0005c871f0aa840.orig/src/CMakeLists.txt +++ sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/CMakeLists.txt @@ -21,14 +21,6 @@ set(GENERATED_PROTO_H "${COMMON_BIN_DIR} set(GENERATED_PROTO_C "${COMMON_BIN_DIR}/${PROTO_NAME}.pb-c.c") get_filename_component(ABS_PATH ${PROTO_FILE} PATH) -add_custom_command( - OUTPUT "${GENERATED_PROTO_C}" - "${GENERATED_PROTO_H}" - COMMAND ${PROTOBUFC_PROTOC_EXECUTABLE} - ARGS --c_out ${COMMON_BIN_DIR} -I ${ABS_PATH} ${PROTO_FILE} - DEPENDS ${PROTO_FILE} - COMMENT "Running C protocol buffer compiler on ${PROTO_FILE}" - VERBATIM ) configure_file("${COMMON_DIR}/sr_constants.h.in" "${COMMON_BIN_DIR}/sr_constants.h" ESCAPE_QUOTES @ONLY) Index: sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/common/sysrepo.pb-c.c =================================================================== --- /dev/null +++ sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/common/sysrepo.pb-c.c @@ -0,0 +1,10537 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: sysrepo.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "sysrepo.pb-c.h" +void sr__value__init + (Sr__Value *message) +{ + static Sr__Value init_value = SR__VALUE__INIT; + *message = init_value; +} +size_t sr__value__get_packed_size + (const Sr__Value *message) +{ + assert(message->base.descriptor == &sr__value__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__value__pack + (const Sr__Value *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__value__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__value__pack_to_buffer + (const Sr__Value *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__value__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Value * + sr__value__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Value *) + protobuf_c_message_unpack (&sr__value__descriptor, + allocator, len, data); +} +void sr__value__free_unpacked + (Sr__Value *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__value__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__node__init + (Sr__Node *message) +{ + static Sr__Node init_value = SR__NODE__INIT; + *message = init_value; +} +size_t sr__node__get_packed_size + (const Sr__Node *message) +{ + assert(message->base.descriptor == &sr__node__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__node__pack + (const Sr__Node *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__node__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__node__pack_to_buffer + (const Sr__Node *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__node__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Node * + sr__node__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Node *) + protobuf_c_message_unpack (&sr__node__descriptor, + allocator, len, data); +} +void sr__node__free_unpacked + (Sr__Node *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__node__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__error__init + (Sr__Error *message) +{ + static Sr__Error init_value = SR__ERROR__INIT; + *message = init_value; +} +size_t sr__error__get_packed_size + (const Sr__Error *message) +{ + assert(message->base.descriptor == &sr__error__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__error__pack + (const Sr__Error *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__error__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__error__pack_to_buffer + (const Sr__Error *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__error__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Error * + sr__error__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Error *) + protobuf_c_message_unpack (&sr__error__descriptor, + allocator, len, data); +} +void sr__error__free_unpacked + (Sr__Error *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__error__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_start_req__init + (Sr__SessionStartReq *message) +{ + static Sr__SessionStartReq init_value = SR__SESSION_START_REQ__INIT; + *message = init_value; +} +size_t sr__session_start_req__get_packed_size + (const Sr__SessionStartReq *message) +{ + assert(message->base.descriptor == &sr__session_start_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_start_req__pack + (const Sr__SessionStartReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_start_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_start_req__pack_to_buffer + (const Sr__SessionStartReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_start_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionStartReq * + sr__session_start_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionStartReq *) + protobuf_c_message_unpack (&sr__session_start_req__descriptor, + allocator, len, data); +} +void sr__session_start_req__free_unpacked + (Sr__SessionStartReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_start_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_start_resp__init + (Sr__SessionStartResp *message) +{ + static Sr__SessionStartResp init_value = SR__SESSION_START_RESP__INIT; + *message = init_value; +} +size_t sr__session_start_resp__get_packed_size + (const Sr__SessionStartResp *message) +{ + assert(message->base.descriptor == &sr__session_start_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_start_resp__pack + (const Sr__SessionStartResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_start_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_start_resp__pack_to_buffer + (const Sr__SessionStartResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_start_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionStartResp * + sr__session_start_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionStartResp *) + protobuf_c_message_unpack (&sr__session_start_resp__descriptor, + allocator, len, data); +} +void sr__session_start_resp__free_unpacked + (Sr__SessionStartResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_start_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_stop_req__init + (Sr__SessionStopReq *message) +{ + static Sr__SessionStopReq init_value = SR__SESSION_STOP_REQ__INIT; + *message = init_value; +} +size_t sr__session_stop_req__get_packed_size + (const Sr__SessionStopReq *message) +{ + assert(message->base.descriptor == &sr__session_stop_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_stop_req__pack + (const Sr__SessionStopReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_stop_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_stop_req__pack_to_buffer + (const Sr__SessionStopReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_stop_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionStopReq * + sr__session_stop_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionStopReq *) + protobuf_c_message_unpack (&sr__session_stop_req__descriptor, + allocator, len, data); +} +void sr__session_stop_req__free_unpacked + (Sr__SessionStopReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_stop_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_stop_resp__init + (Sr__SessionStopResp *message) +{ + static Sr__SessionStopResp init_value = SR__SESSION_STOP_RESP__INIT; + *message = init_value; +} +size_t sr__session_stop_resp__get_packed_size + (const Sr__SessionStopResp *message) +{ + assert(message->base.descriptor == &sr__session_stop_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_stop_resp__pack + (const Sr__SessionStopResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_stop_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_stop_resp__pack_to_buffer + (const Sr__SessionStopResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_stop_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionStopResp * + sr__session_stop_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionStopResp *) + protobuf_c_message_unpack (&sr__session_stop_resp__descriptor, + allocator, len, data); +} +void sr__session_stop_resp__free_unpacked + (Sr__SessionStopResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_stop_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_refresh_req__init + (Sr__SessionRefreshReq *message) +{ + static Sr__SessionRefreshReq init_value = SR__SESSION_REFRESH_REQ__INIT; + *message = init_value; +} +size_t sr__session_refresh_req__get_packed_size + (const Sr__SessionRefreshReq *message) +{ + assert(message->base.descriptor == &sr__session_refresh_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_refresh_req__pack + (const Sr__SessionRefreshReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_refresh_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_refresh_req__pack_to_buffer + (const Sr__SessionRefreshReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_refresh_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionRefreshReq * + sr__session_refresh_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionRefreshReq *) + protobuf_c_message_unpack (&sr__session_refresh_req__descriptor, + allocator, len, data); +} +void sr__session_refresh_req__free_unpacked + (Sr__SessionRefreshReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_refresh_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_refresh_resp__init + (Sr__SessionRefreshResp *message) +{ + static Sr__SessionRefreshResp init_value = SR__SESSION_REFRESH_RESP__INIT; + *message = init_value; +} +size_t sr__session_refresh_resp__get_packed_size + (const Sr__SessionRefreshResp *message) +{ + assert(message->base.descriptor == &sr__session_refresh_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_refresh_resp__pack + (const Sr__SessionRefreshResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_refresh_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_refresh_resp__pack_to_buffer + (const Sr__SessionRefreshResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_refresh_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionRefreshResp * + sr__session_refresh_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionRefreshResp *) + protobuf_c_message_unpack (&sr__session_refresh_resp__descriptor, + allocator, len, data); +} +void sr__session_refresh_resp__free_unpacked + (Sr__SessionRefreshResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_refresh_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_check_req__init + (Sr__SessionCheckReq *message) +{ + static Sr__SessionCheckReq init_value = SR__SESSION_CHECK_REQ__INIT; + *message = init_value; +} +size_t sr__session_check_req__get_packed_size + (const Sr__SessionCheckReq *message) +{ + assert(message->base.descriptor == &sr__session_check_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_check_req__pack + (const Sr__SessionCheckReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_check_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_check_req__pack_to_buffer + (const Sr__SessionCheckReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_check_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionCheckReq * + sr__session_check_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionCheckReq *) + protobuf_c_message_unpack (&sr__session_check_req__descriptor, + allocator, len, data); +} +void sr__session_check_req__free_unpacked + (Sr__SessionCheckReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_check_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_check_resp__init + (Sr__SessionCheckResp *message) +{ + static Sr__SessionCheckResp init_value = SR__SESSION_CHECK_RESP__INIT; + *message = init_value; +} +size_t sr__session_check_resp__get_packed_size + (const Sr__SessionCheckResp *message) +{ + assert(message->base.descriptor == &sr__session_check_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_check_resp__pack + (const Sr__SessionCheckResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_check_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_check_resp__pack_to_buffer + (const Sr__SessionCheckResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_check_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionCheckResp * + sr__session_check_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionCheckResp *) + protobuf_c_message_unpack (&sr__session_check_resp__descriptor, + allocator, len, data); +} +void sr__session_check_resp__free_unpacked + (Sr__SessionCheckResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_check_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_switch_ds_req__init + (Sr__SessionSwitchDsReq *message) +{ + static Sr__SessionSwitchDsReq init_value = SR__SESSION_SWITCH_DS_REQ__INIT; + *message = init_value; +} +size_t sr__session_switch_ds_req__get_packed_size + (const Sr__SessionSwitchDsReq *message) +{ + assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_switch_ds_req__pack + (const Sr__SessionSwitchDsReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_switch_ds_req__pack_to_buffer + (const Sr__SessionSwitchDsReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionSwitchDsReq * + sr__session_switch_ds_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionSwitchDsReq *) + protobuf_c_message_unpack (&sr__session_switch_ds_req__descriptor, + allocator, len, data); +} +void sr__session_switch_ds_req__free_unpacked + (Sr__SessionSwitchDsReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_switch_ds_resp__init + (Sr__SessionSwitchDsResp *message) +{ + static Sr__SessionSwitchDsResp init_value = SR__SESSION_SWITCH_DS_RESP__INIT; + *message = init_value; +} +size_t sr__session_switch_ds_resp__get_packed_size + (const Sr__SessionSwitchDsResp *message) +{ + assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_switch_ds_resp__pack + (const Sr__SessionSwitchDsResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_switch_ds_resp__pack_to_buffer + (const Sr__SessionSwitchDsResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionSwitchDsResp * + sr__session_switch_ds_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionSwitchDsResp *) + protobuf_c_message_unpack (&sr__session_switch_ds_resp__descriptor, + allocator, len, data); +} +void sr__session_switch_ds_resp__free_unpacked + (Sr__SessionSwitchDsResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_set_opts_req__init + (Sr__SessionSetOptsReq *message) +{ + static Sr__SessionSetOptsReq init_value = SR__SESSION_SET_OPTS_REQ__INIT; + *message = init_value; +} +size_t sr__session_set_opts_req__get_packed_size + (const Sr__SessionSetOptsReq *message) +{ + assert(message->base.descriptor == &sr__session_set_opts_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_set_opts_req__pack + (const Sr__SessionSetOptsReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_set_opts_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_set_opts_req__pack_to_buffer + (const Sr__SessionSetOptsReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_set_opts_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionSetOptsReq * + sr__session_set_opts_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionSetOptsReq *) + protobuf_c_message_unpack (&sr__session_set_opts_req__descriptor, + allocator, len, data); +} +void sr__session_set_opts_req__free_unpacked + (Sr__SessionSetOptsReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_set_opts_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__session_set_opts_resp__init + (Sr__SessionSetOptsResp *message) +{ + static Sr__SessionSetOptsResp init_value = SR__SESSION_SET_OPTS_RESP__INIT; + *message = init_value; +} +size_t sr__session_set_opts_resp__get_packed_size + (const Sr__SessionSetOptsResp *message) +{ + assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__session_set_opts_resp__pack + (const Sr__SessionSetOptsResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__session_set_opts_resp__pack_to_buffer + (const Sr__SessionSetOptsResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SessionSetOptsResp * + sr__session_set_opts_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SessionSetOptsResp *) + protobuf_c_message_unpack (&sr__session_set_opts_resp__descriptor, + allocator, len, data); +} +void sr__session_set_opts_resp__free_unpacked + (Sr__SessionSetOptsResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__version_verify_req__init + (Sr__VersionVerifyReq *message) +{ + static Sr__VersionVerifyReq init_value = SR__VERSION_VERIFY_REQ__INIT; + *message = init_value; +} +size_t sr__version_verify_req__get_packed_size + (const Sr__VersionVerifyReq *message) +{ + assert(message->base.descriptor == &sr__version_verify_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__version_verify_req__pack + (const Sr__VersionVerifyReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__version_verify_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__version_verify_req__pack_to_buffer + (const Sr__VersionVerifyReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__version_verify_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__VersionVerifyReq * + sr__version_verify_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__VersionVerifyReq *) + protobuf_c_message_unpack (&sr__version_verify_req__descriptor, + allocator, len, data); +} +void sr__version_verify_req__free_unpacked + (Sr__VersionVerifyReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__version_verify_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__version_verify_resp__init + (Sr__VersionVerifyResp *message) +{ + static Sr__VersionVerifyResp init_value = SR__VERSION_VERIFY_RESP__INIT; + *message = init_value; +} +size_t sr__version_verify_resp__get_packed_size + (const Sr__VersionVerifyResp *message) +{ + assert(message->base.descriptor == &sr__version_verify_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__version_verify_resp__pack + (const Sr__VersionVerifyResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__version_verify_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__version_verify_resp__pack_to_buffer + (const Sr__VersionVerifyResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__version_verify_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__VersionVerifyResp * + sr__version_verify_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__VersionVerifyResp *) + protobuf_c_message_unpack (&sr__version_verify_resp__descriptor, + allocator, len, data); +} +void sr__version_verify_resp__free_unpacked + (Sr__VersionVerifyResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__version_verify_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__schema_revision__init + (Sr__SchemaRevision *message) +{ + static Sr__SchemaRevision init_value = SR__SCHEMA_REVISION__INIT; + *message = init_value; +} +size_t sr__schema_revision__get_packed_size + (const Sr__SchemaRevision *message) +{ + assert(message->base.descriptor == &sr__schema_revision__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__schema_revision__pack + (const Sr__SchemaRevision *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__schema_revision__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__schema_revision__pack_to_buffer + (const Sr__SchemaRevision *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__schema_revision__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SchemaRevision * + sr__schema_revision__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SchemaRevision *) + protobuf_c_message_unpack (&sr__schema_revision__descriptor, + allocator, len, data); +} +void sr__schema_revision__free_unpacked + (Sr__SchemaRevision *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__schema_revision__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__schema_submodule__init + (Sr__SchemaSubmodule *message) +{ + static Sr__SchemaSubmodule init_value = SR__SCHEMA_SUBMODULE__INIT; + *message = init_value; +} +size_t sr__schema_submodule__get_packed_size + (const Sr__SchemaSubmodule *message) +{ + assert(message->base.descriptor == &sr__schema_submodule__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__schema_submodule__pack + (const Sr__SchemaSubmodule *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__schema_submodule__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__schema_submodule__pack_to_buffer + (const Sr__SchemaSubmodule *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__schema_submodule__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SchemaSubmodule * + sr__schema_submodule__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SchemaSubmodule *) + protobuf_c_message_unpack (&sr__schema_submodule__descriptor, + allocator, len, data); +} +void sr__schema_submodule__free_unpacked + (Sr__SchemaSubmodule *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__schema_submodule__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__schema__init + (Sr__Schema *message) +{ + static Sr__Schema init_value = SR__SCHEMA__INIT; + *message = init_value; +} +size_t sr__schema__get_packed_size + (const Sr__Schema *message) +{ + assert(message->base.descriptor == &sr__schema__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__schema__pack + (const Sr__Schema *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__schema__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__schema__pack_to_buffer + (const Sr__Schema *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__schema__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Schema * + sr__schema__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Schema *) + protobuf_c_message_unpack (&sr__schema__descriptor, + allocator, len, data); +} +void sr__schema__free_unpacked + (Sr__Schema *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__schema__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__list_schemas_req__init + (Sr__ListSchemasReq *message) +{ + static Sr__ListSchemasReq init_value = SR__LIST_SCHEMAS_REQ__INIT; + *message = init_value; +} +size_t sr__list_schemas_req__get_packed_size + (const Sr__ListSchemasReq *message) +{ + assert(message->base.descriptor == &sr__list_schemas_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__list_schemas_req__pack + (const Sr__ListSchemasReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__list_schemas_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__list_schemas_req__pack_to_buffer + (const Sr__ListSchemasReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__list_schemas_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__ListSchemasReq * + sr__list_schemas_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__ListSchemasReq *) + protobuf_c_message_unpack (&sr__list_schemas_req__descriptor, + allocator, len, data); +} +void sr__list_schemas_req__free_unpacked + (Sr__ListSchemasReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__list_schemas_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__list_schemas_resp__init + (Sr__ListSchemasResp *message) +{ + static Sr__ListSchemasResp init_value = SR__LIST_SCHEMAS_RESP__INIT; + *message = init_value; +} +size_t sr__list_schemas_resp__get_packed_size + (const Sr__ListSchemasResp *message) +{ + assert(message->base.descriptor == &sr__list_schemas_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__list_schemas_resp__pack + (const Sr__ListSchemasResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__list_schemas_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__list_schemas_resp__pack_to_buffer + (const Sr__ListSchemasResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__list_schemas_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__ListSchemasResp * + sr__list_schemas_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__ListSchemasResp *) + protobuf_c_message_unpack (&sr__list_schemas_resp__descriptor, + allocator, len, data); +} +void sr__list_schemas_resp__free_unpacked + (Sr__ListSchemasResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__list_schemas_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_schema_req__init + (Sr__GetSchemaReq *message) +{ + static Sr__GetSchemaReq init_value = SR__GET_SCHEMA_REQ__INIT; + *message = init_value; +} +size_t sr__get_schema_req__get_packed_size + (const Sr__GetSchemaReq *message) +{ + assert(message->base.descriptor == &sr__get_schema_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_schema_req__pack + (const Sr__GetSchemaReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_schema_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_schema_req__pack_to_buffer + (const Sr__GetSchemaReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_schema_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetSchemaReq * + sr__get_schema_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetSchemaReq *) + protobuf_c_message_unpack (&sr__get_schema_req__descriptor, + allocator, len, data); +} +void sr__get_schema_req__free_unpacked + (Sr__GetSchemaReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_schema_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_schema_resp__init + (Sr__GetSchemaResp *message) +{ + static Sr__GetSchemaResp init_value = SR__GET_SCHEMA_RESP__INIT; + *message = init_value; +} +size_t sr__get_schema_resp__get_packed_size + (const Sr__GetSchemaResp *message) +{ + assert(message->base.descriptor == &sr__get_schema_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_schema_resp__pack + (const Sr__GetSchemaResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_schema_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_schema_resp__pack_to_buffer + (const Sr__GetSchemaResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_schema_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetSchemaResp * + sr__get_schema_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetSchemaResp *) + protobuf_c_message_unpack (&sr__get_schema_resp__descriptor, + allocator, len, data); +} +void sr__get_schema_resp__free_unpacked + (Sr__GetSchemaResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_schema_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_item_req__init + (Sr__GetItemReq *message) +{ + static Sr__GetItemReq init_value = SR__GET_ITEM_REQ__INIT; + *message = init_value; +} +size_t sr__get_item_req__get_packed_size + (const Sr__GetItemReq *message) +{ + assert(message->base.descriptor == &sr__get_item_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_item_req__pack + (const Sr__GetItemReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_item_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_item_req__pack_to_buffer + (const Sr__GetItemReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_item_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetItemReq * + sr__get_item_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetItemReq *) + protobuf_c_message_unpack (&sr__get_item_req__descriptor, + allocator, len, data); +} +void sr__get_item_req__free_unpacked + (Sr__GetItemReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_item_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_item_resp__init + (Sr__GetItemResp *message) +{ + static Sr__GetItemResp init_value = SR__GET_ITEM_RESP__INIT; + *message = init_value; +} +size_t sr__get_item_resp__get_packed_size + (const Sr__GetItemResp *message) +{ + assert(message->base.descriptor == &sr__get_item_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_item_resp__pack + (const Sr__GetItemResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_item_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_item_resp__pack_to_buffer + (const Sr__GetItemResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_item_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetItemResp * + sr__get_item_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetItemResp *) + protobuf_c_message_unpack (&sr__get_item_resp__descriptor, + allocator, len, data); +} +void sr__get_item_resp__free_unpacked + (Sr__GetItemResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_item_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_items_req__init + (Sr__GetItemsReq *message) +{ + static Sr__GetItemsReq init_value = SR__GET_ITEMS_REQ__INIT; + *message = init_value; +} +size_t sr__get_items_req__get_packed_size + (const Sr__GetItemsReq *message) +{ + assert(message->base.descriptor == &sr__get_items_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_items_req__pack + (const Sr__GetItemsReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_items_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_items_req__pack_to_buffer + (const Sr__GetItemsReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_items_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetItemsReq * + sr__get_items_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetItemsReq *) + protobuf_c_message_unpack (&sr__get_items_req__descriptor, + allocator, len, data); +} +void sr__get_items_req__free_unpacked + (Sr__GetItemsReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_items_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_items_resp__init + (Sr__GetItemsResp *message) +{ + static Sr__GetItemsResp init_value = SR__GET_ITEMS_RESP__INIT; + *message = init_value; +} +size_t sr__get_items_resp__get_packed_size + (const Sr__GetItemsResp *message) +{ + assert(message->base.descriptor == &sr__get_items_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_items_resp__pack + (const Sr__GetItemsResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_items_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_items_resp__pack_to_buffer + (const Sr__GetItemsResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_items_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetItemsResp * + sr__get_items_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetItemsResp *) + protobuf_c_message_unpack (&sr__get_items_resp__descriptor, + allocator, len, data); +} +void sr__get_items_resp__free_unpacked + (Sr__GetItemsResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_items_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_subtree_req__init + (Sr__GetSubtreeReq *message) +{ + static Sr__GetSubtreeReq init_value = SR__GET_SUBTREE_REQ__INIT; + *message = init_value; +} +size_t sr__get_subtree_req__get_packed_size + (const Sr__GetSubtreeReq *message) +{ + assert(message->base.descriptor == &sr__get_subtree_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_subtree_req__pack + (const Sr__GetSubtreeReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_subtree_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_subtree_req__pack_to_buffer + (const Sr__GetSubtreeReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_subtree_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetSubtreeReq * + sr__get_subtree_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetSubtreeReq *) + protobuf_c_message_unpack (&sr__get_subtree_req__descriptor, + allocator, len, data); +} +void sr__get_subtree_req__free_unpacked + (Sr__GetSubtreeReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_subtree_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_subtree_resp__init + (Sr__GetSubtreeResp *message) +{ + static Sr__GetSubtreeResp init_value = SR__GET_SUBTREE_RESP__INIT; + *message = init_value; +} +size_t sr__get_subtree_resp__get_packed_size + (const Sr__GetSubtreeResp *message) +{ + assert(message->base.descriptor == &sr__get_subtree_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_subtree_resp__pack + (const Sr__GetSubtreeResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_subtree_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_subtree_resp__pack_to_buffer + (const Sr__GetSubtreeResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_subtree_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetSubtreeResp * + sr__get_subtree_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetSubtreeResp *) + protobuf_c_message_unpack (&sr__get_subtree_resp__descriptor, + allocator, len, data); +} +void sr__get_subtree_resp__free_unpacked + (Sr__GetSubtreeResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_subtree_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_subtrees_req__init + (Sr__GetSubtreesReq *message) +{ + static Sr__GetSubtreesReq init_value = SR__GET_SUBTREES_REQ__INIT; + *message = init_value; +} +size_t sr__get_subtrees_req__get_packed_size + (const Sr__GetSubtreesReq *message) +{ + assert(message->base.descriptor == &sr__get_subtrees_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_subtrees_req__pack + (const Sr__GetSubtreesReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_subtrees_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_subtrees_req__pack_to_buffer + (const Sr__GetSubtreesReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_subtrees_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetSubtreesReq * + sr__get_subtrees_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetSubtreesReq *) + protobuf_c_message_unpack (&sr__get_subtrees_req__descriptor, + allocator, len, data); +} +void sr__get_subtrees_req__free_unpacked + (Sr__GetSubtreesReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_subtrees_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_subtrees_resp__init + (Sr__GetSubtreesResp *message) +{ + static Sr__GetSubtreesResp init_value = SR__GET_SUBTREES_RESP__INIT; + *message = init_value; +} +size_t sr__get_subtrees_resp__get_packed_size + (const Sr__GetSubtreesResp *message) +{ + assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_subtrees_resp__pack + (const Sr__GetSubtreesResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_subtrees_resp__pack_to_buffer + (const Sr__GetSubtreesResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetSubtreesResp * + sr__get_subtrees_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetSubtreesResp *) + protobuf_c_message_unpack (&sr__get_subtrees_resp__descriptor, + allocator, len, data); +} +void sr__get_subtrees_resp__free_unpacked + (Sr__GetSubtreesResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_subtree_chunk_req__init + (Sr__GetSubtreeChunkReq *message) +{ + static Sr__GetSubtreeChunkReq init_value = SR__GET_SUBTREE_CHUNK_REQ__INIT; + *message = init_value; +} +size_t sr__get_subtree_chunk_req__get_packed_size + (const Sr__GetSubtreeChunkReq *message) +{ + assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_subtree_chunk_req__pack + (const Sr__GetSubtreeChunkReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_subtree_chunk_req__pack_to_buffer + (const Sr__GetSubtreeChunkReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetSubtreeChunkReq * + sr__get_subtree_chunk_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetSubtreeChunkReq *) + protobuf_c_message_unpack (&sr__get_subtree_chunk_req__descriptor, + allocator, len, data); +} +void sr__get_subtree_chunk_req__free_unpacked + (Sr__GetSubtreeChunkReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_subtree_chunk_resp__init + (Sr__GetSubtreeChunkResp *message) +{ + static Sr__GetSubtreeChunkResp init_value = SR__GET_SUBTREE_CHUNK_RESP__INIT; + *message = init_value; +} +size_t sr__get_subtree_chunk_resp__get_packed_size + (const Sr__GetSubtreeChunkResp *message) +{ + assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_subtree_chunk_resp__pack + (const Sr__GetSubtreeChunkResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_subtree_chunk_resp__pack_to_buffer + (const Sr__GetSubtreeChunkResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetSubtreeChunkResp * + sr__get_subtree_chunk_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetSubtreeChunkResp *) + protobuf_c_message_unpack (&sr__get_subtree_chunk_resp__descriptor, + allocator, len, data); +} +void sr__get_subtree_chunk_resp__free_unpacked + (Sr__GetSubtreeChunkResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__set_item_req__init + (Sr__SetItemReq *message) +{ + static Sr__SetItemReq init_value = SR__SET_ITEM_REQ__INIT; + *message = init_value; +} +size_t sr__set_item_req__get_packed_size + (const Sr__SetItemReq *message) +{ + assert(message->base.descriptor == &sr__set_item_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__set_item_req__pack + (const Sr__SetItemReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__set_item_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__set_item_req__pack_to_buffer + (const Sr__SetItemReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__set_item_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SetItemReq * + sr__set_item_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SetItemReq *) + protobuf_c_message_unpack (&sr__set_item_req__descriptor, + allocator, len, data); +} +void sr__set_item_req__free_unpacked + (Sr__SetItemReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__set_item_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__set_item_resp__init + (Sr__SetItemResp *message) +{ + static Sr__SetItemResp init_value = SR__SET_ITEM_RESP__INIT; + *message = init_value; +} +size_t sr__set_item_resp__get_packed_size + (const Sr__SetItemResp *message) +{ + assert(message->base.descriptor == &sr__set_item_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__set_item_resp__pack + (const Sr__SetItemResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__set_item_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__set_item_resp__pack_to_buffer + (const Sr__SetItemResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__set_item_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SetItemResp * + sr__set_item_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SetItemResp *) + protobuf_c_message_unpack (&sr__set_item_resp__descriptor, + allocator, len, data); +} +void sr__set_item_resp__free_unpacked + (Sr__SetItemResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__set_item_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__set_item_str_req__init + (Sr__SetItemStrReq *message) +{ + static Sr__SetItemStrReq init_value = SR__SET_ITEM_STR_REQ__INIT; + *message = init_value; +} +size_t sr__set_item_str_req__get_packed_size + (const Sr__SetItemStrReq *message) +{ + assert(message->base.descriptor == &sr__set_item_str_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__set_item_str_req__pack + (const Sr__SetItemStrReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__set_item_str_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__set_item_str_req__pack_to_buffer + (const Sr__SetItemStrReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__set_item_str_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SetItemStrReq * + sr__set_item_str_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SetItemStrReq *) + protobuf_c_message_unpack (&sr__set_item_str_req__descriptor, + allocator, len, data); +} +void sr__set_item_str_req__free_unpacked + (Sr__SetItemStrReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__set_item_str_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__set_item_str_resp__init + (Sr__SetItemStrResp *message) +{ + static Sr__SetItemStrResp init_value = SR__SET_ITEM_STR_RESP__INIT; + *message = init_value; +} +size_t sr__set_item_str_resp__get_packed_size + (const Sr__SetItemStrResp *message) +{ + assert(message->base.descriptor == &sr__set_item_str_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__set_item_str_resp__pack + (const Sr__SetItemStrResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__set_item_str_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__set_item_str_resp__pack_to_buffer + (const Sr__SetItemStrResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__set_item_str_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SetItemStrResp * + sr__set_item_str_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SetItemStrResp *) + protobuf_c_message_unpack (&sr__set_item_str_resp__descriptor, + allocator, len, data); +} +void sr__set_item_str_resp__free_unpacked + (Sr__SetItemStrResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__set_item_str_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__delete_item_req__init + (Sr__DeleteItemReq *message) +{ + static Sr__DeleteItemReq init_value = SR__DELETE_ITEM_REQ__INIT; + *message = init_value; +} +size_t sr__delete_item_req__get_packed_size + (const Sr__DeleteItemReq *message) +{ + assert(message->base.descriptor == &sr__delete_item_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__delete_item_req__pack + (const Sr__DeleteItemReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__delete_item_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__delete_item_req__pack_to_buffer + (const Sr__DeleteItemReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__delete_item_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__DeleteItemReq * + sr__delete_item_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__DeleteItemReq *) + protobuf_c_message_unpack (&sr__delete_item_req__descriptor, + allocator, len, data); +} +void sr__delete_item_req__free_unpacked + (Sr__DeleteItemReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__delete_item_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__delete_item_resp__init + (Sr__DeleteItemResp *message) +{ + static Sr__DeleteItemResp init_value = SR__DELETE_ITEM_RESP__INIT; + *message = init_value; +} +size_t sr__delete_item_resp__get_packed_size + (const Sr__DeleteItemResp *message) +{ + assert(message->base.descriptor == &sr__delete_item_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__delete_item_resp__pack + (const Sr__DeleteItemResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__delete_item_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__delete_item_resp__pack_to_buffer + (const Sr__DeleteItemResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__delete_item_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__DeleteItemResp * + sr__delete_item_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__DeleteItemResp *) + protobuf_c_message_unpack (&sr__delete_item_resp__descriptor, + allocator, len, data); +} +void sr__delete_item_resp__free_unpacked + (Sr__DeleteItemResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__delete_item_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__move_item_req__init + (Sr__MoveItemReq *message) +{ + static Sr__MoveItemReq init_value = SR__MOVE_ITEM_REQ__INIT; + *message = init_value; +} +size_t sr__move_item_req__get_packed_size + (const Sr__MoveItemReq *message) +{ + assert(message->base.descriptor == &sr__move_item_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__move_item_req__pack + (const Sr__MoveItemReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__move_item_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__move_item_req__pack_to_buffer + (const Sr__MoveItemReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__move_item_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__MoveItemReq * + sr__move_item_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__MoveItemReq *) + protobuf_c_message_unpack (&sr__move_item_req__descriptor, + allocator, len, data); +} +void sr__move_item_req__free_unpacked + (Sr__MoveItemReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__move_item_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__move_item_resp__init + (Sr__MoveItemResp *message) +{ + static Sr__MoveItemResp init_value = SR__MOVE_ITEM_RESP__INIT; + *message = init_value; +} +size_t sr__move_item_resp__get_packed_size + (const Sr__MoveItemResp *message) +{ + assert(message->base.descriptor == &sr__move_item_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__move_item_resp__pack + (const Sr__MoveItemResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__move_item_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__move_item_resp__pack_to_buffer + (const Sr__MoveItemResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__move_item_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__MoveItemResp * + sr__move_item_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__MoveItemResp *) + protobuf_c_message_unpack (&sr__move_item_resp__descriptor, + allocator, len, data); +} +void sr__move_item_resp__free_unpacked + (Sr__MoveItemResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__move_item_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__validate_req__init + (Sr__ValidateReq *message) +{ + static Sr__ValidateReq init_value = SR__VALIDATE_REQ__INIT; + *message = init_value; +} +size_t sr__validate_req__get_packed_size + (const Sr__ValidateReq *message) +{ + assert(message->base.descriptor == &sr__validate_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__validate_req__pack + (const Sr__ValidateReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__validate_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__validate_req__pack_to_buffer + (const Sr__ValidateReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__validate_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__ValidateReq * + sr__validate_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__ValidateReq *) + protobuf_c_message_unpack (&sr__validate_req__descriptor, + allocator, len, data); +} +void sr__validate_req__free_unpacked + (Sr__ValidateReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__validate_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__validate_resp__init + (Sr__ValidateResp *message) +{ + static Sr__ValidateResp init_value = SR__VALIDATE_RESP__INIT; + *message = init_value; +} +size_t sr__validate_resp__get_packed_size + (const Sr__ValidateResp *message) +{ + assert(message->base.descriptor == &sr__validate_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__validate_resp__pack + (const Sr__ValidateResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__validate_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__validate_resp__pack_to_buffer + (const Sr__ValidateResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__validate_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__ValidateResp * + sr__validate_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__ValidateResp *) + protobuf_c_message_unpack (&sr__validate_resp__descriptor, + allocator, len, data); +} +void sr__validate_resp__free_unpacked + (Sr__ValidateResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__validate_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__commit_req__init + (Sr__CommitReq *message) +{ + static Sr__CommitReq init_value = SR__COMMIT_REQ__INIT; + *message = init_value; +} +size_t sr__commit_req__get_packed_size + (const Sr__CommitReq *message) +{ + assert(message->base.descriptor == &sr__commit_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__commit_req__pack + (const Sr__CommitReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__commit_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__commit_req__pack_to_buffer + (const Sr__CommitReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__commit_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CommitReq * + sr__commit_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CommitReq *) + protobuf_c_message_unpack (&sr__commit_req__descriptor, + allocator, len, data); +} +void sr__commit_req__free_unpacked + (Sr__CommitReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__commit_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__commit_resp__init + (Sr__CommitResp *message) +{ + static Sr__CommitResp init_value = SR__COMMIT_RESP__INIT; + *message = init_value; +} +size_t sr__commit_resp__get_packed_size + (const Sr__CommitResp *message) +{ + assert(message->base.descriptor == &sr__commit_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__commit_resp__pack + (const Sr__CommitResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__commit_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__commit_resp__pack_to_buffer + (const Sr__CommitResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__commit_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CommitResp * + sr__commit_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CommitResp *) + protobuf_c_message_unpack (&sr__commit_resp__descriptor, + allocator, len, data); +} +void sr__commit_resp__free_unpacked + (Sr__CommitResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__commit_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__discard_changes_req__init + (Sr__DiscardChangesReq *message) +{ + static Sr__DiscardChangesReq init_value = SR__DISCARD_CHANGES_REQ__INIT; + *message = init_value; +} +size_t sr__discard_changes_req__get_packed_size + (const Sr__DiscardChangesReq *message) +{ + assert(message->base.descriptor == &sr__discard_changes_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__discard_changes_req__pack + (const Sr__DiscardChangesReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__discard_changes_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__discard_changes_req__pack_to_buffer + (const Sr__DiscardChangesReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__discard_changes_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__DiscardChangesReq * + sr__discard_changes_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__DiscardChangesReq *) + protobuf_c_message_unpack (&sr__discard_changes_req__descriptor, + allocator, len, data); +} +void sr__discard_changes_req__free_unpacked + (Sr__DiscardChangesReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__discard_changes_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__discard_changes_resp__init + (Sr__DiscardChangesResp *message) +{ + static Sr__DiscardChangesResp init_value = SR__DISCARD_CHANGES_RESP__INIT; + *message = init_value; +} +size_t sr__discard_changes_resp__get_packed_size + (const Sr__DiscardChangesResp *message) +{ + assert(message->base.descriptor == &sr__discard_changes_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__discard_changes_resp__pack + (const Sr__DiscardChangesResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__discard_changes_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__discard_changes_resp__pack_to_buffer + (const Sr__DiscardChangesResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__discard_changes_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__DiscardChangesResp * + sr__discard_changes_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__DiscardChangesResp *) + protobuf_c_message_unpack (&sr__discard_changes_resp__descriptor, + allocator, len, data); +} +void sr__discard_changes_resp__free_unpacked + (Sr__DiscardChangesResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__discard_changes_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__copy_config_req__init + (Sr__CopyConfigReq *message) +{ + static Sr__CopyConfigReq init_value = SR__COPY_CONFIG_REQ__INIT; + *message = init_value; +} +size_t sr__copy_config_req__get_packed_size + (const Sr__CopyConfigReq *message) +{ + assert(message->base.descriptor == &sr__copy_config_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__copy_config_req__pack + (const Sr__CopyConfigReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__copy_config_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__copy_config_req__pack_to_buffer + (const Sr__CopyConfigReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__copy_config_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CopyConfigReq * + sr__copy_config_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CopyConfigReq *) + protobuf_c_message_unpack (&sr__copy_config_req__descriptor, + allocator, len, data); +} +void sr__copy_config_req__free_unpacked + (Sr__CopyConfigReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__copy_config_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__copy_config_resp__init + (Sr__CopyConfigResp *message) +{ + static Sr__CopyConfigResp init_value = SR__COPY_CONFIG_RESP__INIT; + *message = init_value; +} +size_t sr__copy_config_resp__get_packed_size + (const Sr__CopyConfigResp *message) +{ + assert(message->base.descriptor == &sr__copy_config_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__copy_config_resp__pack + (const Sr__CopyConfigResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__copy_config_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__copy_config_resp__pack_to_buffer + (const Sr__CopyConfigResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__copy_config_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CopyConfigResp * + sr__copy_config_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CopyConfigResp *) + protobuf_c_message_unpack (&sr__copy_config_resp__descriptor, + allocator, len, data); +} +void sr__copy_config_resp__free_unpacked + (Sr__CopyConfigResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__copy_config_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__lock_req__init + (Sr__LockReq *message) +{ + static Sr__LockReq init_value = SR__LOCK_REQ__INIT; + *message = init_value; +} +size_t sr__lock_req__get_packed_size + (const Sr__LockReq *message) +{ + assert(message->base.descriptor == &sr__lock_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__lock_req__pack + (const Sr__LockReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__lock_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__lock_req__pack_to_buffer + (const Sr__LockReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__lock_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__LockReq * + sr__lock_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__LockReq *) + protobuf_c_message_unpack (&sr__lock_req__descriptor, + allocator, len, data); +} +void sr__lock_req__free_unpacked + (Sr__LockReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__lock_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__lock_resp__init + (Sr__LockResp *message) +{ + static Sr__LockResp init_value = SR__LOCK_RESP__INIT; + *message = init_value; +} +size_t sr__lock_resp__get_packed_size + (const Sr__LockResp *message) +{ + assert(message->base.descriptor == &sr__lock_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__lock_resp__pack + (const Sr__LockResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__lock_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__lock_resp__pack_to_buffer + (const Sr__LockResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__lock_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__LockResp * + sr__lock_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__LockResp *) + protobuf_c_message_unpack (&sr__lock_resp__descriptor, + allocator, len, data); +} +void sr__lock_resp__free_unpacked + (Sr__LockResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__lock_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__unlock_req__init + (Sr__UnlockReq *message) +{ + static Sr__UnlockReq init_value = SR__UNLOCK_REQ__INIT; + *message = init_value; +} +size_t sr__unlock_req__get_packed_size + (const Sr__UnlockReq *message) +{ + assert(message->base.descriptor == &sr__unlock_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__unlock_req__pack + (const Sr__UnlockReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__unlock_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__unlock_req__pack_to_buffer + (const Sr__UnlockReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__unlock_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__UnlockReq * + sr__unlock_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__UnlockReq *) + protobuf_c_message_unpack (&sr__unlock_req__descriptor, + allocator, len, data); +} +void sr__unlock_req__free_unpacked + (Sr__UnlockReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__unlock_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__unlock_resp__init + (Sr__UnlockResp *message) +{ + static Sr__UnlockResp init_value = SR__UNLOCK_RESP__INIT; + *message = init_value; +} +size_t sr__unlock_resp__get_packed_size + (const Sr__UnlockResp *message) +{ + assert(message->base.descriptor == &sr__unlock_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__unlock_resp__pack + (const Sr__UnlockResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__unlock_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__unlock_resp__pack_to_buffer + (const Sr__UnlockResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__unlock_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__UnlockResp * + sr__unlock_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__UnlockResp *) + protobuf_c_message_unpack (&sr__unlock_resp__descriptor, + allocator, len, data); +} +void sr__unlock_resp__free_unpacked + (Sr__UnlockResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__unlock_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__subscribe_req__init + (Sr__SubscribeReq *message) +{ + static Sr__SubscribeReq init_value = SR__SUBSCRIBE_REQ__INIT; + *message = init_value; +} +size_t sr__subscribe_req__get_packed_size + (const Sr__SubscribeReq *message) +{ + assert(message->base.descriptor == &sr__subscribe_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__subscribe_req__pack + (const Sr__SubscribeReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__subscribe_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__subscribe_req__pack_to_buffer + (const Sr__SubscribeReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__subscribe_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SubscribeReq * + sr__subscribe_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SubscribeReq *) + protobuf_c_message_unpack (&sr__subscribe_req__descriptor, + allocator, len, data); +} +void sr__subscribe_req__free_unpacked + (Sr__SubscribeReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__subscribe_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__subscribe_resp__init + (Sr__SubscribeResp *message) +{ + static Sr__SubscribeResp init_value = SR__SUBSCRIBE_RESP__INIT; + *message = init_value; +} +size_t sr__subscribe_resp__get_packed_size + (const Sr__SubscribeResp *message) +{ + assert(message->base.descriptor == &sr__subscribe_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__subscribe_resp__pack + (const Sr__SubscribeResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__subscribe_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__subscribe_resp__pack_to_buffer + (const Sr__SubscribeResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__subscribe_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SubscribeResp * + sr__subscribe_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SubscribeResp *) + protobuf_c_message_unpack (&sr__subscribe_resp__descriptor, + allocator, len, data); +} +void sr__subscribe_resp__free_unpacked + (Sr__SubscribeResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__subscribe_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__unsubscribe_req__init + (Sr__UnsubscribeReq *message) +{ + static Sr__UnsubscribeReq init_value = SR__UNSUBSCRIBE_REQ__INIT; + *message = init_value; +} +size_t sr__unsubscribe_req__get_packed_size + (const Sr__UnsubscribeReq *message) +{ + assert(message->base.descriptor == &sr__unsubscribe_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__unsubscribe_req__pack + (const Sr__UnsubscribeReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__unsubscribe_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__unsubscribe_req__pack_to_buffer + (const Sr__UnsubscribeReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__unsubscribe_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__UnsubscribeReq * + sr__unsubscribe_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__UnsubscribeReq *) + protobuf_c_message_unpack (&sr__unsubscribe_req__descriptor, + allocator, len, data); +} +void sr__unsubscribe_req__free_unpacked + (Sr__UnsubscribeReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__unsubscribe_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__unsubscribe_resp__init + (Sr__UnsubscribeResp *message) +{ + static Sr__UnsubscribeResp init_value = SR__UNSUBSCRIBE_RESP__INIT; + *message = init_value; +} +size_t sr__unsubscribe_resp__get_packed_size + (const Sr__UnsubscribeResp *message) +{ + assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__unsubscribe_resp__pack + (const Sr__UnsubscribeResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__unsubscribe_resp__pack_to_buffer + (const Sr__UnsubscribeResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__UnsubscribeResp * + sr__unsubscribe_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__UnsubscribeResp *) + protobuf_c_message_unpack (&sr__unsubscribe_resp__descriptor, + allocator, len, data); +} +void sr__unsubscribe_resp__free_unpacked + (Sr__UnsubscribeResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__check_enabled_running_req__init + (Sr__CheckEnabledRunningReq *message) +{ + static Sr__CheckEnabledRunningReq init_value = SR__CHECK_ENABLED_RUNNING_REQ__INIT; + *message = init_value; +} +size_t sr__check_enabled_running_req__get_packed_size + (const Sr__CheckEnabledRunningReq *message) +{ + assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__check_enabled_running_req__pack + (const Sr__CheckEnabledRunningReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__check_enabled_running_req__pack_to_buffer + (const Sr__CheckEnabledRunningReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CheckEnabledRunningReq * + sr__check_enabled_running_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CheckEnabledRunningReq *) + protobuf_c_message_unpack (&sr__check_enabled_running_req__descriptor, + allocator, len, data); +} +void sr__check_enabled_running_req__free_unpacked + (Sr__CheckEnabledRunningReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__check_enabled_running_resp__init + (Sr__CheckEnabledRunningResp *message) +{ + static Sr__CheckEnabledRunningResp init_value = SR__CHECK_ENABLED_RUNNING_RESP__INIT; + *message = init_value; +} +size_t sr__check_enabled_running_resp__get_packed_size + (const Sr__CheckEnabledRunningResp *message) +{ + assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__check_enabled_running_resp__pack + (const Sr__CheckEnabledRunningResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__check_enabled_running_resp__pack_to_buffer + (const Sr__CheckEnabledRunningResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CheckEnabledRunningResp * + sr__check_enabled_running_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CheckEnabledRunningResp *) + protobuf_c_message_unpack (&sr__check_enabled_running_resp__descriptor, + allocator, len, data); +} +void sr__check_enabled_running_resp__free_unpacked + (Sr__CheckEnabledRunningResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__module_install_notification__init + (Sr__ModuleInstallNotification *message) +{ + static Sr__ModuleInstallNotification init_value = SR__MODULE_INSTALL_NOTIFICATION__INIT; + *message = init_value; +} +size_t sr__module_install_notification__get_packed_size + (const Sr__ModuleInstallNotification *message) +{ + assert(message->base.descriptor == &sr__module_install_notification__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__module_install_notification__pack + (const Sr__ModuleInstallNotification *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__module_install_notification__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__module_install_notification__pack_to_buffer + (const Sr__ModuleInstallNotification *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__module_install_notification__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__ModuleInstallNotification * + sr__module_install_notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__ModuleInstallNotification *) + protobuf_c_message_unpack (&sr__module_install_notification__descriptor, + allocator, len, data); +} +void sr__module_install_notification__free_unpacked + (Sr__ModuleInstallNotification *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__module_install_notification__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__feature_enable_notification__init + (Sr__FeatureEnableNotification *message) +{ + static Sr__FeatureEnableNotification init_value = SR__FEATURE_ENABLE_NOTIFICATION__INIT; + *message = init_value; +} +size_t sr__feature_enable_notification__get_packed_size + (const Sr__FeatureEnableNotification *message) +{ + assert(message->base.descriptor == &sr__feature_enable_notification__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__feature_enable_notification__pack + (const Sr__FeatureEnableNotification *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__feature_enable_notification__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__feature_enable_notification__pack_to_buffer + (const Sr__FeatureEnableNotification *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__feature_enable_notification__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__FeatureEnableNotification * + sr__feature_enable_notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__FeatureEnableNotification *) + protobuf_c_message_unpack (&sr__feature_enable_notification__descriptor, + allocator, len, data); +} +void sr__feature_enable_notification__free_unpacked + (Sr__FeatureEnableNotification *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__feature_enable_notification__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__module_change_notification__init + (Sr__ModuleChangeNotification *message) +{ + static Sr__ModuleChangeNotification init_value = SR__MODULE_CHANGE_NOTIFICATION__INIT; + *message = init_value; +} +size_t sr__module_change_notification__get_packed_size + (const Sr__ModuleChangeNotification *message) +{ + assert(message->base.descriptor == &sr__module_change_notification__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__module_change_notification__pack + (const Sr__ModuleChangeNotification *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__module_change_notification__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__module_change_notification__pack_to_buffer + (const Sr__ModuleChangeNotification *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__module_change_notification__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__ModuleChangeNotification * + sr__module_change_notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__ModuleChangeNotification *) + protobuf_c_message_unpack (&sr__module_change_notification__descriptor, + allocator, len, data); +} +void sr__module_change_notification__free_unpacked + (Sr__ModuleChangeNotification *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__module_change_notification__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__subtree_change_notification__init + (Sr__SubtreeChangeNotification *message) +{ + static Sr__SubtreeChangeNotification init_value = SR__SUBTREE_CHANGE_NOTIFICATION__INIT; + *message = init_value; +} +size_t sr__subtree_change_notification__get_packed_size + (const Sr__SubtreeChangeNotification *message) +{ + assert(message->base.descriptor == &sr__subtree_change_notification__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__subtree_change_notification__pack + (const Sr__SubtreeChangeNotification *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__subtree_change_notification__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__subtree_change_notification__pack_to_buffer + (const Sr__SubtreeChangeNotification *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__subtree_change_notification__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__SubtreeChangeNotification * + sr__subtree_change_notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__SubtreeChangeNotification *) + protobuf_c_message_unpack (&sr__subtree_change_notification__descriptor, + allocator, len, data); +} +void sr__subtree_change_notification__free_unpacked + (Sr__SubtreeChangeNotification *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__subtree_change_notification__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__change__init + (Sr__Change *message) +{ + static Sr__Change init_value = SR__CHANGE__INIT; + *message = init_value; +} +size_t sr__change__get_packed_size + (const Sr__Change *message) +{ + assert(message->base.descriptor == &sr__change__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__change__pack + (const Sr__Change *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__change__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__change__pack_to_buffer + (const Sr__Change *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__change__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Change * + sr__change__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Change *) + protobuf_c_message_unpack (&sr__change__descriptor, + allocator, len, data); +} +void sr__change__free_unpacked + (Sr__Change *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__change__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_changes_req__init + (Sr__GetChangesReq *message) +{ + static Sr__GetChangesReq init_value = SR__GET_CHANGES_REQ__INIT; + *message = init_value; +} +size_t sr__get_changes_req__get_packed_size + (const Sr__GetChangesReq *message) +{ + assert(message->base.descriptor == &sr__get_changes_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_changes_req__pack + (const Sr__GetChangesReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_changes_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_changes_req__pack_to_buffer + (const Sr__GetChangesReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_changes_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetChangesReq * + sr__get_changes_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetChangesReq *) + protobuf_c_message_unpack (&sr__get_changes_req__descriptor, + allocator, len, data); +} +void sr__get_changes_req__free_unpacked + (Sr__GetChangesReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_changes_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__get_changes_resp__init + (Sr__GetChangesResp *message) +{ + static Sr__GetChangesResp init_value = SR__GET_CHANGES_RESP__INIT; + *message = init_value; +} +size_t sr__get_changes_resp__get_packed_size + (const Sr__GetChangesResp *message) +{ + assert(message->base.descriptor == &sr__get_changes_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__get_changes_resp__pack + (const Sr__GetChangesResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__get_changes_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__get_changes_resp__pack_to_buffer + (const Sr__GetChangesResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__get_changes_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__GetChangesResp * + sr__get_changes_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__GetChangesResp *) + protobuf_c_message_unpack (&sr__get_changes_resp__descriptor, + allocator, len, data); +} +void sr__get_changes_resp__free_unpacked + (Sr__GetChangesResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__get_changes_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__check_exec_perm_req__init + (Sr__CheckExecPermReq *message) +{ + static Sr__CheckExecPermReq init_value = SR__CHECK_EXEC_PERM_REQ__INIT; + *message = init_value; +} +size_t sr__check_exec_perm_req__get_packed_size + (const Sr__CheckExecPermReq *message) +{ + assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__check_exec_perm_req__pack + (const Sr__CheckExecPermReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__check_exec_perm_req__pack_to_buffer + (const Sr__CheckExecPermReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CheckExecPermReq * + sr__check_exec_perm_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CheckExecPermReq *) + protobuf_c_message_unpack (&sr__check_exec_perm_req__descriptor, + allocator, len, data); +} +void sr__check_exec_perm_req__free_unpacked + (Sr__CheckExecPermReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__check_exec_perm_resp__init + (Sr__CheckExecPermResp *message) +{ + static Sr__CheckExecPermResp init_value = SR__CHECK_EXEC_PERM_RESP__INIT; + *message = init_value; +} +size_t sr__check_exec_perm_resp__get_packed_size + (const Sr__CheckExecPermResp *message) +{ + assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__check_exec_perm_resp__pack + (const Sr__CheckExecPermResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__check_exec_perm_resp__pack_to_buffer + (const Sr__CheckExecPermResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CheckExecPermResp * + sr__check_exec_perm_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CheckExecPermResp *) + protobuf_c_message_unpack (&sr__check_exec_perm_resp__descriptor, + allocator, len, data); +} +void sr__check_exec_perm_resp__free_unpacked + (Sr__CheckExecPermResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__rpcreq__init + (Sr__RPCReq *message) +{ + static Sr__RPCReq init_value = SR__RPCREQ__INIT; + *message = init_value; +} +size_t sr__rpcreq__get_packed_size + (const Sr__RPCReq *message) +{ + assert(message->base.descriptor == &sr__rpcreq__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__rpcreq__pack + (const Sr__RPCReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__rpcreq__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__rpcreq__pack_to_buffer + (const Sr__RPCReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__rpcreq__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__RPCReq * + sr__rpcreq__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__RPCReq *) + protobuf_c_message_unpack (&sr__rpcreq__descriptor, + allocator, len, data); +} +void sr__rpcreq__free_unpacked + (Sr__RPCReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__rpcreq__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__rpcresp__init + (Sr__RPCResp *message) +{ + static Sr__RPCResp init_value = SR__RPCRESP__INIT; + *message = init_value; +} +size_t sr__rpcresp__get_packed_size + (const Sr__RPCResp *message) +{ + assert(message->base.descriptor == &sr__rpcresp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__rpcresp__pack + (const Sr__RPCResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__rpcresp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__rpcresp__pack_to_buffer + (const Sr__RPCResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__rpcresp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__RPCResp * + sr__rpcresp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__RPCResp *) + protobuf_c_message_unpack (&sr__rpcresp__descriptor, + allocator, len, data); +} +void sr__rpcresp__free_unpacked + (Sr__RPCResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__rpcresp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__event_notif_req__init + (Sr__EventNotifReq *message) +{ + static Sr__EventNotifReq init_value = SR__EVENT_NOTIF_REQ__INIT; + *message = init_value; +} +size_t sr__event_notif_req__get_packed_size + (const Sr__EventNotifReq *message) +{ + assert(message->base.descriptor == &sr__event_notif_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__event_notif_req__pack + (const Sr__EventNotifReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__event_notif_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__event_notif_req__pack_to_buffer + (const Sr__EventNotifReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__event_notif_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__EventNotifReq * + sr__event_notif_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__EventNotifReq *) + protobuf_c_message_unpack (&sr__event_notif_req__descriptor, + allocator, len, data); +} +void sr__event_notif_req__free_unpacked + (Sr__EventNotifReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__event_notif_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__event_notif_resp__init + (Sr__EventNotifResp *message) +{ + static Sr__EventNotifResp init_value = SR__EVENT_NOTIF_RESP__INIT; + *message = init_value; +} +size_t sr__event_notif_resp__get_packed_size + (const Sr__EventNotifResp *message) +{ + assert(message->base.descriptor == &sr__event_notif_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__event_notif_resp__pack + (const Sr__EventNotifResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__event_notif_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__event_notif_resp__pack_to_buffer + (const Sr__EventNotifResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__event_notif_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__EventNotifResp * + sr__event_notif_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__EventNotifResp *) + protobuf_c_message_unpack (&sr__event_notif_resp__descriptor, + allocator, len, data); +} +void sr__event_notif_resp__free_unpacked + (Sr__EventNotifResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__event_notif_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__event_notif_replay_req__init + (Sr__EventNotifReplayReq *message) +{ + static Sr__EventNotifReplayReq init_value = SR__EVENT_NOTIF_REPLAY_REQ__INIT; + *message = init_value; +} +size_t sr__event_notif_replay_req__get_packed_size + (const Sr__EventNotifReplayReq *message) +{ + assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__event_notif_replay_req__pack + (const Sr__EventNotifReplayReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__event_notif_replay_req__pack_to_buffer + (const Sr__EventNotifReplayReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__EventNotifReplayReq * + sr__event_notif_replay_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__EventNotifReplayReq *) + protobuf_c_message_unpack (&sr__event_notif_replay_req__descriptor, + allocator, len, data); +} +void sr__event_notif_replay_req__free_unpacked + (Sr__EventNotifReplayReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__event_notif_replay_resp__init + (Sr__EventNotifReplayResp *message) +{ + static Sr__EventNotifReplayResp init_value = SR__EVENT_NOTIF_REPLAY_RESP__INIT; + *message = init_value; +} +size_t sr__event_notif_replay_resp__get_packed_size + (const Sr__EventNotifReplayResp *message) +{ + assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__event_notif_replay_resp__pack + (const Sr__EventNotifReplayResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__event_notif_replay_resp__pack_to_buffer + (const Sr__EventNotifReplayResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__EventNotifReplayResp * + sr__event_notif_replay_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__EventNotifReplayResp *) + protobuf_c_message_unpack (&sr__event_notif_replay_resp__descriptor, + allocator, len, data); +} +void sr__event_notif_replay_resp__free_unpacked + (Sr__EventNotifReplayResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__data_provide_req__init + (Sr__DataProvideReq *message) +{ + static Sr__DataProvideReq init_value = SR__DATA_PROVIDE_REQ__INIT; + *message = init_value; +} +size_t sr__data_provide_req__get_packed_size + (const Sr__DataProvideReq *message) +{ + assert(message->base.descriptor == &sr__data_provide_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__data_provide_req__pack + (const Sr__DataProvideReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__data_provide_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__data_provide_req__pack_to_buffer + (const Sr__DataProvideReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__data_provide_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__DataProvideReq * + sr__data_provide_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__DataProvideReq *) + protobuf_c_message_unpack (&sr__data_provide_req__descriptor, + allocator, len, data); +} +void sr__data_provide_req__free_unpacked + (Sr__DataProvideReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__data_provide_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__data_provide_resp__init + (Sr__DataProvideResp *message) +{ + static Sr__DataProvideResp init_value = SR__DATA_PROVIDE_RESP__INIT; + *message = init_value; +} +size_t sr__data_provide_resp__get_packed_size + (const Sr__DataProvideResp *message) +{ + assert(message->base.descriptor == &sr__data_provide_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__data_provide_resp__pack + (const Sr__DataProvideResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__data_provide_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__data_provide_resp__pack_to_buffer + (const Sr__DataProvideResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__data_provide_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__DataProvideResp * + sr__data_provide_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__DataProvideResp *) + protobuf_c_message_unpack (&sr__data_provide_resp__descriptor, + allocator, len, data); +} +void sr__data_provide_resp__free_unpacked + (Sr__DataProvideResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__data_provide_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__module_install_req__init + (Sr__ModuleInstallReq *message) +{ + static Sr__ModuleInstallReq init_value = SR__MODULE_INSTALL_REQ__INIT; + *message = init_value; +} +size_t sr__module_install_req__get_packed_size + (const Sr__ModuleInstallReq *message) +{ + assert(message->base.descriptor == &sr__module_install_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__module_install_req__pack + (const Sr__ModuleInstallReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__module_install_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__module_install_req__pack_to_buffer + (const Sr__ModuleInstallReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__module_install_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__ModuleInstallReq * + sr__module_install_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__ModuleInstallReq *) + protobuf_c_message_unpack (&sr__module_install_req__descriptor, + allocator, len, data); +} +void sr__module_install_req__free_unpacked + (Sr__ModuleInstallReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__module_install_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__module_install_resp__init + (Sr__ModuleInstallResp *message) +{ + static Sr__ModuleInstallResp init_value = SR__MODULE_INSTALL_RESP__INIT; + *message = init_value; +} +size_t sr__module_install_resp__get_packed_size + (const Sr__ModuleInstallResp *message) +{ + assert(message->base.descriptor == &sr__module_install_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__module_install_resp__pack + (const Sr__ModuleInstallResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__module_install_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__module_install_resp__pack_to_buffer + (const Sr__ModuleInstallResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__module_install_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__ModuleInstallResp * + sr__module_install_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__ModuleInstallResp *) + protobuf_c_message_unpack (&sr__module_install_resp__descriptor, + allocator, len, data); +} +void sr__module_install_resp__free_unpacked + (Sr__ModuleInstallResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__module_install_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__feature_enable_req__init + (Sr__FeatureEnableReq *message) +{ + static Sr__FeatureEnableReq init_value = SR__FEATURE_ENABLE_REQ__INIT; + *message = init_value; +} +size_t sr__feature_enable_req__get_packed_size + (const Sr__FeatureEnableReq *message) +{ + assert(message->base.descriptor == &sr__feature_enable_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__feature_enable_req__pack + (const Sr__FeatureEnableReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__feature_enable_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__feature_enable_req__pack_to_buffer + (const Sr__FeatureEnableReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__feature_enable_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__FeatureEnableReq * + sr__feature_enable_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__FeatureEnableReq *) + protobuf_c_message_unpack (&sr__feature_enable_req__descriptor, + allocator, len, data); +} +void sr__feature_enable_req__free_unpacked + (Sr__FeatureEnableReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__feature_enable_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__feature_enable_resp__init + (Sr__FeatureEnableResp *message) +{ + static Sr__FeatureEnableResp init_value = SR__FEATURE_ENABLE_RESP__INIT; + *message = init_value; +} +size_t sr__feature_enable_resp__get_packed_size + (const Sr__FeatureEnableResp *message) +{ + assert(message->base.descriptor == &sr__feature_enable_resp__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__feature_enable_resp__pack + (const Sr__FeatureEnableResp *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__feature_enable_resp__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__feature_enable_resp__pack_to_buffer + (const Sr__FeatureEnableResp *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__feature_enable_resp__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__FeatureEnableResp * + sr__feature_enable_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__FeatureEnableResp *) + protobuf_c_message_unpack (&sr__feature_enable_resp__descriptor, + allocator, len, data); +} +void sr__feature_enable_resp__free_unpacked + (Sr__FeatureEnableResp *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__feature_enable_resp__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__unsubscribe_destination_req__init + (Sr__UnsubscribeDestinationReq *message) +{ + static Sr__UnsubscribeDestinationReq init_value = SR__UNSUBSCRIBE_DESTINATION_REQ__INIT; + *message = init_value; +} +size_t sr__unsubscribe_destination_req__get_packed_size + (const Sr__UnsubscribeDestinationReq *message) +{ + assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__unsubscribe_destination_req__pack + (const Sr__UnsubscribeDestinationReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__unsubscribe_destination_req__pack_to_buffer + (const Sr__UnsubscribeDestinationReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__UnsubscribeDestinationReq * + sr__unsubscribe_destination_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__UnsubscribeDestinationReq *) + protobuf_c_message_unpack (&sr__unsubscribe_destination_req__descriptor, + allocator, len, data); +} +void sr__unsubscribe_destination_req__free_unpacked + (Sr__UnsubscribeDestinationReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__commit_timeout_req__init + (Sr__CommitTimeoutReq *message) +{ + static Sr__CommitTimeoutReq init_value = SR__COMMIT_TIMEOUT_REQ__INIT; + *message = init_value; +} +size_t sr__commit_timeout_req__get_packed_size + (const Sr__CommitTimeoutReq *message) +{ + assert(message->base.descriptor == &sr__commit_timeout_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__commit_timeout_req__pack + (const Sr__CommitTimeoutReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__commit_timeout_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__commit_timeout_req__pack_to_buffer + (const Sr__CommitTimeoutReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__commit_timeout_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__CommitTimeoutReq * + sr__commit_timeout_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__CommitTimeoutReq *) + protobuf_c_message_unpack (&sr__commit_timeout_req__descriptor, + allocator, len, data); +} +void sr__commit_timeout_req__free_unpacked + (Sr__CommitTimeoutReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__commit_timeout_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__oper_data_timeout_req__init + (Sr__OperDataTimeoutReq *message) +{ + static Sr__OperDataTimeoutReq init_value = SR__OPER_DATA_TIMEOUT_REQ__INIT; + *message = init_value; +} +size_t sr__oper_data_timeout_req__get_packed_size + (const Sr__OperDataTimeoutReq *message) +{ + assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__oper_data_timeout_req__pack + (const Sr__OperDataTimeoutReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__oper_data_timeout_req__pack_to_buffer + (const Sr__OperDataTimeoutReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__OperDataTimeoutReq * + sr__oper_data_timeout_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__OperDataTimeoutReq *) + protobuf_c_message_unpack (&sr__oper_data_timeout_req__descriptor, + allocator, len, data); +} +void sr__oper_data_timeout_req__free_unpacked + (Sr__OperDataTimeoutReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__internal_state_data_req__init + (Sr__InternalStateDataReq *message) +{ + static Sr__InternalStateDataReq init_value = SR__INTERNAL_STATE_DATA_REQ__INIT; + *message = init_value; +} +size_t sr__internal_state_data_req__get_packed_size + (const Sr__InternalStateDataReq *message) +{ + assert(message->base.descriptor == &sr__internal_state_data_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__internal_state_data_req__pack + (const Sr__InternalStateDataReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__internal_state_data_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__internal_state_data_req__pack_to_buffer + (const Sr__InternalStateDataReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__internal_state_data_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__InternalStateDataReq * + sr__internal_state_data_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__InternalStateDataReq *) + protobuf_c_message_unpack (&sr__internal_state_data_req__descriptor, + allocator, len, data); +} +void sr__internal_state_data_req__free_unpacked + (Sr__InternalStateDataReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__internal_state_data_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__notif_store_cleanup_req__init + (Sr__NotifStoreCleanupReq *message) +{ + static Sr__NotifStoreCleanupReq init_value = SR__NOTIF_STORE_CLEANUP_REQ__INIT; + *message = init_value; +} +size_t sr__notif_store_cleanup_req__get_packed_size + (const Sr__NotifStoreCleanupReq *message) +{ + assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__notif_store_cleanup_req__pack + (const Sr__NotifStoreCleanupReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__notif_store_cleanup_req__pack_to_buffer + (const Sr__NotifStoreCleanupReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__NotifStoreCleanupReq * + sr__notif_store_cleanup_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__NotifStoreCleanupReq *) + protobuf_c_message_unpack (&sr__notif_store_cleanup_req__descriptor, + allocator, len, data); +} +void sr__notif_store_cleanup_req__free_unpacked + (Sr__NotifStoreCleanupReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__delayed_msg_req__init + (Sr__DelayedMsgReq *message) +{ + static Sr__DelayedMsgReq init_value = SR__DELAYED_MSG_REQ__INIT; + *message = init_value; +} +size_t sr__delayed_msg_req__get_packed_size + (const Sr__DelayedMsgReq *message) +{ + assert(message->base.descriptor == &sr__delayed_msg_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__delayed_msg_req__pack + (const Sr__DelayedMsgReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__delayed_msg_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__delayed_msg_req__pack_to_buffer + (const Sr__DelayedMsgReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__delayed_msg_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__DelayedMsgReq * + sr__delayed_msg_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__DelayedMsgReq *) + protobuf_c_message_unpack (&sr__delayed_msg_req__descriptor, + allocator, len, data); +} +void sr__delayed_msg_req__free_unpacked + (Sr__DelayedMsgReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__delayed_msg_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__nacm_reload_req__init + (Sr__NacmReloadReq *message) +{ + static Sr__NacmReloadReq init_value = SR__NACM_RELOAD_REQ__INIT; + *message = init_value; +} +size_t sr__nacm_reload_req__get_packed_size + (const Sr__NacmReloadReq *message) +{ + assert(message->base.descriptor == &sr__nacm_reload_req__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__nacm_reload_req__pack + (const Sr__NacmReloadReq *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__nacm_reload_req__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__nacm_reload_req__pack_to_buffer + (const Sr__NacmReloadReq *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__nacm_reload_req__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__NacmReloadReq * + sr__nacm_reload_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__NacmReloadReq *) + protobuf_c_message_unpack (&sr__nacm_reload_req__descriptor, + allocator, len, data); +} +void sr__nacm_reload_req__free_unpacked + (Sr__NacmReloadReq *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__nacm_reload_req__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__request__init + (Sr__Request *message) +{ + static Sr__Request init_value = SR__REQUEST__INIT; + *message = init_value; +} +size_t sr__request__get_packed_size + (const Sr__Request *message) +{ + assert(message->base.descriptor == &sr__request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__request__pack + (const Sr__Request *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__request__pack_to_buffer + (const Sr__Request *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Request * + sr__request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Request *) + protobuf_c_message_unpack (&sr__request__descriptor, + allocator, len, data); +} +void sr__request__free_unpacked + (Sr__Request *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__response__init + (Sr__Response *message) +{ + static Sr__Response init_value = SR__RESPONSE__INIT; + *message = init_value; +} +size_t sr__response__get_packed_size + (const Sr__Response *message) +{ + assert(message->base.descriptor == &sr__response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__response__pack + (const Sr__Response *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__response__pack_to_buffer + (const Sr__Response *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Response * + sr__response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Response *) + protobuf_c_message_unpack (&sr__response__descriptor, + allocator, len, data); +} +void sr__response__free_unpacked + (Sr__Response *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__notification__init + (Sr__Notification *message) +{ + static Sr__Notification init_value = SR__NOTIFICATION__INIT; + *message = init_value; +} +size_t sr__notification__get_packed_size + (const Sr__Notification *message) +{ + assert(message->base.descriptor == &sr__notification__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__notification__pack + (const Sr__Notification *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__notification__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__notification__pack_to_buffer + (const Sr__Notification *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__notification__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Notification * + sr__notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Notification *) + protobuf_c_message_unpack (&sr__notification__descriptor, + allocator, len, data); +} +void sr__notification__free_unpacked + (Sr__Notification *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__notification__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__notification_ack__init + (Sr__NotificationAck *message) +{ + static Sr__NotificationAck init_value = SR__NOTIFICATION_ACK__INIT; + *message = init_value; +} +size_t sr__notification_ack__get_packed_size + (const Sr__NotificationAck *message) +{ + assert(message->base.descriptor == &sr__notification_ack__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__notification_ack__pack + (const Sr__NotificationAck *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__notification_ack__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__notification_ack__pack_to_buffer + (const Sr__NotificationAck *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__notification_ack__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__NotificationAck * + sr__notification_ack__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__NotificationAck *) + protobuf_c_message_unpack (&sr__notification_ack__descriptor, + allocator, len, data); +} +void sr__notification_ack__free_unpacked + (Sr__NotificationAck *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__notification_ack__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__internal_request__init + (Sr__InternalRequest *message) +{ + static Sr__InternalRequest init_value = SR__INTERNAL_REQUEST__INIT; + *message = init_value; +} +size_t sr__internal_request__get_packed_size + (const Sr__InternalRequest *message) +{ + assert(message->base.descriptor == &sr__internal_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__internal_request__pack + (const Sr__InternalRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__internal_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__internal_request__pack_to_buffer + (const Sr__InternalRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__internal_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__InternalRequest * + sr__internal_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__InternalRequest *) + protobuf_c_message_unpack (&sr__internal_request__descriptor, + allocator, len, data); +} +void sr__internal_request__free_unpacked + (Sr__InternalRequest *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__internal_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sr__msg__init + (Sr__Msg *message) +{ + static Sr__Msg init_value = SR__MSG__INIT; + *message = init_value; +} +size_t sr__msg__get_packed_size + (const Sr__Msg *message) +{ + assert(message->base.descriptor == &sr__msg__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sr__msg__pack + (const Sr__Msg *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sr__msg__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sr__msg__pack_to_buffer + (const Sr__Msg *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sr__msg__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sr__Msg * + sr__msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sr__Msg *) + protobuf_c_message_unpack (&sr__msg__descriptor, + allocator, len, data); +} +void sr__msg__free_unpacked + (Sr__Msg *message, + ProtobufCAllocator *allocator) +{ + assert(message->base.descriptor == &sr__msg__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCEnumValue sr__value__types__enum_values_by_number[22] = +{ + { "LIST", "SR__VALUE__TYPES__LIST", 1 }, + { "CONTAINER", "SR__VALUE__TYPES__CONTAINER", 2 }, + { "CONTAINER_PRESENCE", "SR__VALUE__TYPES__CONTAINER_PRESENCE", 3 }, + { "LEAF_EMPTY", "SR__VALUE__TYPES__LEAF_EMPTY", 4 }, + { "BINARY", "SR__VALUE__TYPES__BINARY", 10 }, + { "BITS", "SR__VALUE__TYPES__BITS", 11 }, + { "BOOL", "SR__VALUE__TYPES__BOOL", 12 }, + { "DECIMAL64", "SR__VALUE__TYPES__DECIMAL64", 13 }, + { "ENUM", "SR__VALUE__TYPES__ENUM", 14 }, + { "IDENTITYREF", "SR__VALUE__TYPES__IDENTITYREF", 15 }, + { "INSTANCEID", "SR__VALUE__TYPES__INSTANCEID", 16 }, + { "INT8", "SR__VALUE__TYPES__INT8", 17 }, + { "INT16", "SR__VALUE__TYPES__INT16", 18 }, + { "INT32", "SR__VALUE__TYPES__INT32", 19 }, + { "INT64", "SR__VALUE__TYPES__INT64", 20 }, + { "STRING", "SR__VALUE__TYPES__STRING", 21 }, + { "UINT8", "SR__VALUE__TYPES__UINT8", 22 }, + { "UINT16", "SR__VALUE__TYPES__UINT16", 23 }, + { "UINT32", "SR__VALUE__TYPES__UINT32", 24 }, + { "UINT64", "SR__VALUE__TYPES__UINT64", 25 }, + { "ANYXML", "SR__VALUE__TYPES__ANYXML", 26 }, + { "ANYDATA", "SR__VALUE__TYPES__ANYDATA", 27 }, +}; +static const ProtobufCIntRange sr__value__types__value_ranges[] = { +{1, 0},{10, 4},{0, 22} +}; +static const ProtobufCEnumValueIndex sr__value__types__enum_values_by_name[22] = +{ + { "ANYDATA", 21 }, + { "ANYXML", 20 }, + { "BINARY", 4 }, + { "BITS", 5 }, + { "BOOL", 6 }, + { "CONTAINER", 1 }, + { "CONTAINER_PRESENCE", 2 }, + { "DECIMAL64", 7 }, + { "ENUM", 8 }, + { "IDENTITYREF", 9 }, + { "INSTANCEID", 10 }, + { "INT16", 12 }, + { "INT32", 13 }, + { "INT64", 14 }, + { "INT8", 11 }, + { "LEAF_EMPTY", 3 }, + { "LIST", 0 }, + { "STRING", 15 }, + { "UINT16", 17 }, + { "UINT32", 18 }, + { "UINT64", 19 }, + { "UINT8", 16 }, +}; +const ProtobufCEnumDescriptor sr__value__types__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.Value.Types", + "Types", + "Sr__Value__Types", + "sr", + 22, + sr__value__types__enum_values_by_number, + 22, + sr__value__types__enum_values_by_name, + 2, + sr__value__types__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor sr__value__field_descriptors[21] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "type", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__Value, type), + &sr__value__types__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dflt", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__Value, dflt), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "binary_val", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, binary_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bits_val", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, bits_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bool_val", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(Sr__Value, has_bool_val), + offsetof(Sr__Value, bool_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "decimal64_val", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_DOUBLE, + offsetof(Sr__Value, has_decimal64_val), + offsetof(Sr__Value, decimal64_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enum_val", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, enum_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "identityref_val", + 15, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, identityref_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "instanceid_val", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, instanceid_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "int8_val", + 17, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(Sr__Value, has_int8_val), + offsetof(Sr__Value, int8_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "int16_val", + 18, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(Sr__Value, has_int16_val), + offsetof(Sr__Value, int16_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "int32_val", + 19, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(Sr__Value, has_int32_val), + offsetof(Sr__Value, int32_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "int64_val", + 20, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT64, + offsetof(Sr__Value, has_int64_val), + offsetof(Sr__Value, int64_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "string_val", + 21, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, string_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "uint8_val", + 22, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__Value, has_uint8_val), + offsetof(Sr__Value, uint8_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "uint16_val", + 23, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__Value, has_uint16_val), + offsetof(Sr__Value, uint16_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "uint32_val", + 24, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__Value, has_uint32_val), + offsetof(Sr__Value, uint32_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "uint64_val", + 25, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT64, + offsetof(Sr__Value, has_uint64_val), + offsetof(Sr__Value, uint64_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "anyxml_val", + 26, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, anyxml_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "anydata_val", + 27, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Value, anydata_val), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__value__field_indices_by_name[] = { + 20, /* field[20] = anydata_val */ + 19, /* field[19] = anyxml_val */ + 3, /* field[3] = binary_val */ + 4, /* field[4] = bits_val */ + 5, /* field[5] = bool_val */ + 6, /* field[6] = decimal64_val */ + 2, /* field[2] = dflt */ + 7, /* field[7] = enum_val */ + 8, /* field[8] = identityref_val */ + 9, /* field[9] = instanceid_val */ + 11, /* field[11] = int16_val */ + 12, /* field[12] = int32_val */ + 13, /* field[13] = int64_val */ + 10, /* field[10] = int8_val */ + 14, /* field[14] = string_val */ + 1, /* field[1] = type */ + 16, /* field[16] = uint16_val */ + 17, /* field[17] = uint32_val */ + 18, /* field[18] = uint64_val */ + 15, /* field[15] = uint8_val */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__value__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 10, 3 }, + { 0, 21 } +}; +const ProtobufCMessageDescriptor sr__value__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Value", + "Value", + "Sr__Value", + "sr", + sizeof(Sr__Value), + 21, + sr__value__field_descriptors, + sr__value__field_indices_by_name, + 2, sr__value__number_ranges, + (ProtobufCMessageInit) sr__value__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__node__field_descriptors[3] = +{ + { + "value", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Node, value), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_name", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Node, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "children", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__Node, n_children), + offsetof(Sr__Node, children), + &sr__node__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__node__field_indices_by_name[] = { + 2, /* field[2] = children */ + 1, /* field[1] = module_name */ + 0, /* field[0] = value */ +}; +static const ProtobufCIntRange sr__node__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__node__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Node", + "Node", + "Sr__Node", + "sr", + sizeof(Sr__Node), + 3, + sr__node__field_descriptors, + sr__node__field_indices_by_name, + 1, sr__node__number_ranges, + (ProtobufCMessageInit) sr__node__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__error__field_descriptors[2] = +{ + { + "message", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Error, message), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "xpath", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Error, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__error__field_indices_by_name[] = { + 0, /* field[0] = message */ + 1, /* field[1] = xpath */ +}; +static const ProtobufCIntRange sr__error__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor sr__error__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Error", + "Error", + "Sr__Error", + "sr", + sizeof(Sr__Error), + 2, + sr__error__field_descriptors, + sr__error__field_indices_by_name, + 1, sr__error__number_ranges, + (ProtobufCMessageInit) sr__error__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__session_start_req__field_descriptors[4] = +{ + { + "datastore", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__SessionStartReq, datastore), + &sr__data_store__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "user_name", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SessionStartReq, user_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "options", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__SessionStartReq, options), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "commit_id", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__SessionStartReq, has_commit_id), + offsetof(Sr__SessionStartReq, commit_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__session_start_req__field_indices_by_name[] = { + 3, /* field[3] = commit_id */ + 0, /* field[0] = datastore */ + 2, /* field[2] = options */ + 1, /* field[1] = user_name */ +}; +static const ProtobufCIntRange sr__session_start_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor sr__session_start_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionStartReq", + "SessionStartReq", + "Sr__SessionStartReq", + "sr", + sizeof(Sr__SessionStartReq), + 4, + sr__session_start_req__field_descriptors, + sr__session_start_req__field_indices_by_name, + 1, sr__session_start_req__number_ranges, + (ProtobufCMessageInit) sr__session_start_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__session_start_resp__field_descriptors[1] = +{ + { + "session_id", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__SessionStartResp, session_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__session_start_resp__field_indices_by_name[] = { + 0, /* field[0] = session_id */ +}; +static const ProtobufCIntRange sr__session_start_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__session_start_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionStartResp", + "SessionStartResp", + "Sr__SessionStartResp", + "sr", + sizeof(Sr__SessionStartResp), + 1, + sr__session_start_resp__field_descriptors, + sr__session_start_resp__field_indices_by_name, + 1, sr__session_start_resp__number_ranges, + (ProtobufCMessageInit) sr__session_start_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__session_stop_req__field_descriptors[1] = +{ + { + "session_id", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__SessionStopReq, session_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__session_stop_req__field_indices_by_name[] = { + 0, /* field[0] = session_id */ +}; +static const ProtobufCIntRange sr__session_stop_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__session_stop_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionStopReq", + "SessionStopReq", + "Sr__SessionStopReq", + "sr", + sizeof(Sr__SessionStopReq), + 1, + sr__session_stop_req__field_descriptors, + sr__session_stop_req__field_indices_by_name, + 1, sr__session_stop_req__number_ranges, + (ProtobufCMessageInit) sr__session_stop_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__session_stop_resp__field_descriptors[1] = +{ + { + "session_id", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__SessionStopResp, session_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__session_stop_resp__field_indices_by_name[] = { + 0, /* field[0] = session_id */ +}; +static const ProtobufCIntRange sr__session_stop_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__session_stop_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionStopResp", + "SessionStopResp", + "Sr__SessionStopResp", + "sr", + sizeof(Sr__SessionStopResp), + 1, + sr__session_stop_resp__field_descriptors, + sr__session_stop_resp__field_indices_by_name, + 1, sr__session_stop_resp__number_ranges, + (ProtobufCMessageInit) sr__session_stop_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__session_refresh_req__field_descriptors NULL +#define sr__session_refresh_req__field_indices_by_name NULL +#define sr__session_refresh_req__number_ranges NULL +const ProtobufCMessageDescriptor sr__session_refresh_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionRefreshReq", + "SessionRefreshReq", + "Sr__SessionRefreshReq", + "sr", + sizeof(Sr__SessionRefreshReq), + 0, + sr__session_refresh_req__field_descriptors, + sr__session_refresh_req__field_indices_by_name, + 0, sr__session_refresh_req__number_ranges, + (ProtobufCMessageInit) sr__session_refresh_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__session_refresh_resp__field_descriptors[1] = +{ + { + "errors", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__SessionRefreshResp, n_errors), + offsetof(Sr__SessionRefreshResp, errors), + &sr__error__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__session_refresh_resp__field_indices_by_name[] = { + 0, /* field[0] = errors */ +}; +static const ProtobufCIntRange sr__session_refresh_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__session_refresh_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionRefreshResp", + "SessionRefreshResp", + "Sr__SessionRefreshResp", + "sr", + sizeof(Sr__SessionRefreshResp), + 1, + sr__session_refresh_resp__field_descriptors, + sr__session_refresh_resp__field_indices_by_name, + 1, sr__session_refresh_resp__number_ranges, + (ProtobufCMessageInit) sr__session_refresh_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__session_check_req__field_descriptors NULL +#define sr__session_check_req__field_indices_by_name NULL +#define sr__session_check_req__number_ranges NULL +const ProtobufCMessageDescriptor sr__session_check_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionCheckReq", + "SessionCheckReq", + "Sr__SessionCheckReq", + "sr", + sizeof(Sr__SessionCheckReq), + 0, + sr__session_check_req__field_descriptors, + sr__session_check_req__field_indices_by_name, + 0, sr__session_check_req__number_ranges, + (ProtobufCMessageInit) sr__session_check_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__session_check_resp__field_descriptors[1] = +{ + { + "errors", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__SessionCheckResp, n_errors), + offsetof(Sr__SessionCheckResp, errors), + &sr__error__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__session_check_resp__field_indices_by_name[] = { + 0, /* field[0] = errors */ +}; +static const ProtobufCIntRange sr__session_check_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__session_check_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionCheckResp", + "SessionCheckResp", + "Sr__SessionCheckResp", + "sr", + sizeof(Sr__SessionCheckResp), + 1, + sr__session_check_resp__field_descriptors, + sr__session_check_resp__field_indices_by_name, + 1, sr__session_check_resp__number_ranges, + (ProtobufCMessageInit) sr__session_check_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__session_switch_ds_req__field_descriptors[1] = +{ + { + "datastore", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__SessionSwitchDsReq, datastore), + &sr__data_store__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__session_switch_ds_req__field_indices_by_name[] = { + 0, /* field[0] = datastore */ +}; +static const ProtobufCIntRange sr__session_switch_ds_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__session_switch_ds_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionSwitchDsReq", + "SessionSwitchDsReq", + "Sr__SessionSwitchDsReq", + "sr", + sizeof(Sr__SessionSwitchDsReq), + 1, + sr__session_switch_ds_req__field_descriptors, + sr__session_switch_ds_req__field_indices_by_name, + 1, sr__session_switch_ds_req__number_ranges, + (ProtobufCMessageInit) sr__session_switch_ds_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__session_switch_ds_resp__field_descriptors NULL +#define sr__session_switch_ds_resp__field_indices_by_name NULL +#define sr__session_switch_ds_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__session_switch_ds_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionSwitchDsResp", + "SessionSwitchDsResp", + "Sr__SessionSwitchDsResp", + "sr", + sizeof(Sr__SessionSwitchDsResp), + 0, + sr__session_switch_ds_resp__field_descriptors, + sr__session_switch_ds_resp__field_indices_by_name, + 0, sr__session_switch_ds_resp__number_ranges, + (ProtobufCMessageInit) sr__session_switch_ds_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__session_set_opts_req__field_descriptors[1] = +{ + { + "options", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__SessionSetOptsReq, options), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__session_set_opts_req__field_indices_by_name[] = { + 0, /* field[0] = options */ +}; +static const ProtobufCIntRange sr__session_set_opts_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__session_set_opts_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionSetOptsReq", + "SessionSetOptsReq", + "Sr__SessionSetOptsReq", + "sr", + sizeof(Sr__SessionSetOptsReq), + 1, + sr__session_set_opts_req__field_descriptors, + sr__session_set_opts_req__field_indices_by_name, + 1, sr__session_set_opts_req__number_ranges, + (ProtobufCMessageInit) sr__session_set_opts_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__session_set_opts_resp__field_descriptors NULL +#define sr__session_set_opts_resp__field_indices_by_name NULL +#define sr__session_set_opts_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__session_set_opts_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SessionSetOptsResp", + "SessionSetOptsResp", + "Sr__SessionSetOptsResp", + "sr", + sizeof(Sr__SessionSetOptsResp), + 0, + sr__session_set_opts_resp__field_descriptors, + sr__session_set_opts_resp__field_indices_by_name, + 0, sr__session_set_opts_resp__number_ranges, + (ProtobufCMessageInit) sr__session_set_opts_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__version_verify_req__field_descriptors[1] = +{ + { + "soname", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__VersionVerifyReq, soname), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__version_verify_req__field_indices_by_name[] = { + 0, /* field[0] = soname */ +}; +static const ProtobufCIntRange sr__version_verify_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__version_verify_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.VersionVerifyReq", + "VersionVerifyReq", + "Sr__VersionVerifyReq", + "sr", + sizeof(Sr__VersionVerifyReq), + 1, + sr__version_verify_req__field_descriptors, + sr__version_verify_req__field_indices_by_name, + 1, sr__version_verify_req__number_ranges, + (ProtobufCMessageInit) sr__version_verify_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__version_verify_resp__field_descriptors[1] = +{ + { + "soname", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__VersionVerifyResp, soname), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__version_verify_resp__field_indices_by_name[] = { + 0, /* field[0] = soname */ +}; +static const ProtobufCIntRange sr__version_verify_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__version_verify_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.VersionVerifyResp", + "VersionVerifyResp", + "Sr__VersionVerifyResp", + "sr", + sizeof(Sr__VersionVerifyResp), + 1, + sr__version_verify_resp__field_descriptors, + sr__version_verify_resp__field_indices_by_name, + 1, sr__version_verify_resp__number_ranges, + (ProtobufCMessageInit) sr__version_verify_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__schema_revision__field_descriptors[3] = +{ + { + "revision", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SchemaRevision, revision), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "file_path_yang", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SchemaRevision, file_path_yang), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "file_path_yin", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SchemaRevision, file_path_yin), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__schema_revision__field_indices_by_name[] = { + 1, /* field[1] = file_path_yang */ + 2, /* field[2] = file_path_yin */ + 0, /* field[0] = revision */ +}; +static const ProtobufCIntRange sr__schema_revision__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__schema_revision__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SchemaRevision", + "SchemaRevision", + "Sr__SchemaRevision", + "sr", + sizeof(Sr__SchemaRevision), + 3, + sr__schema_revision__field_descriptors, + sr__schema_revision__field_indices_by_name, + 1, sr__schema_revision__number_ranges, + (ProtobufCMessageInit) sr__schema_revision__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__schema_submodule__field_descriptors[2] = +{ + { + "submodule_name", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SchemaSubmodule, submodule_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "revision", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__SchemaSubmodule, revision), + &sr__schema_revision__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__schema_submodule__field_indices_by_name[] = { + 1, /* field[1] = revision */ + 0, /* field[0] = submodule_name */ +}; +static const ProtobufCIntRange sr__schema_submodule__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor sr__schema_submodule__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SchemaSubmodule", + "SchemaSubmodule", + "Sr__SchemaSubmodule", + "sr", + sizeof(Sr__SchemaSubmodule), + 2, + sr__schema_submodule__field_descriptors, + sr__schema_submodule__field_indices_by_name, + 1, sr__schema_submodule__number_ranges, + (ProtobufCMessageInit) sr__schema_submodule__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__schema__field_descriptors[8] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Schema, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ns", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Schema, ns), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "prefix", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Schema, prefix), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "installed", + 4, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__Schema, installed), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "implemented", + 5, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__Schema, implemented), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "revision", + 6, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Schema, revision), + &sr__schema_revision__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "submodules", + 7, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__Schema, n_submodules), + offsetof(Sr__Schema, submodules), + &sr__schema_submodule__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enabled_features", + 8, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_STRING, + offsetof(Sr__Schema, n_enabled_features), + offsetof(Sr__Schema, enabled_features), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__schema__field_indices_by_name[] = { + 7, /* field[7] = enabled_features */ + 4, /* field[4] = implemented */ + 3, /* field[3] = installed */ + 0, /* field[0] = module_name */ + 1, /* field[1] = ns */ + 2, /* field[2] = prefix */ + 5, /* field[5] = revision */ + 6, /* field[6] = submodules */ +}; +static const ProtobufCIntRange sr__schema__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 8 } +}; +const ProtobufCMessageDescriptor sr__schema__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Schema", + "Schema", + "Sr__Schema", + "sr", + sizeof(Sr__Schema), + 8, + sr__schema__field_descriptors, + sr__schema__field_indices_by_name, + 1, sr__schema__number_ranges, + (ProtobufCMessageInit) sr__schema__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__list_schemas_req__field_descriptors NULL +#define sr__list_schemas_req__field_indices_by_name NULL +#define sr__list_schemas_req__number_ranges NULL +const ProtobufCMessageDescriptor sr__list_schemas_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.ListSchemasReq", + "ListSchemasReq", + "Sr__ListSchemasReq", + "sr", + sizeof(Sr__ListSchemasReq), + 0, + sr__list_schemas_req__field_descriptors, + sr__list_schemas_req__field_indices_by_name, + 0, sr__list_schemas_req__number_ranges, + (ProtobufCMessageInit) sr__list_schemas_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__list_schemas_resp__field_descriptors[1] = +{ + { + "schemas", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__ListSchemasResp, n_schemas), + offsetof(Sr__ListSchemasResp, schemas), + &sr__schema__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__list_schemas_resp__field_indices_by_name[] = { + 0, /* field[0] = schemas */ +}; +static const ProtobufCIntRange sr__list_schemas_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__list_schemas_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.ListSchemasResp", + "ListSchemasResp", + "Sr__ListSchemasResp", + "sr", + sizeof(Sr__ListSchemasResp), + 1, + sr__list_schemas_resp__field_descriptors, + sr__list_schemas_resp__field_indices_by_name, + 1, sr__list_schemas_resp__number_ranges, + (ProtobufCMessageInit) sr__list_schemas_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_schema_req__field_descriptors[5] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetSchemaReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "revision", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetSchemaReq, revision), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "submodule_name", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetSchemaReq, submodule_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "submodule_revision", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetSchemaReq, submodule_revision), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "yang_format", + 5, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__GetSchemaReq, yang_format), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_schema_req__field_indices_by_name[] = { + 0, /* field[0] = module_name */ + 1, /* field[1] = revision */ + 2, /* field[2] = submodule_name */ + 3, /* field[3] = submodule_revision */ + 4, /* field[4] = yang_format */ +}; +static const ProtobufCIntRange sr__get_schema_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor sr__get_schema_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetSchemaReq", + "GetSchemaReq", + "Sr__GetSchemaReq", + "sr", + sizeof(Sr__GetSchemaReq), + 5, + sr__get_schema_req__field_descriptors, + sr__get_schema_req__field_indices_by_name, + 1, sr__get_schema_req__number_ranges, + (ProtobufCMessageInit) sr__get_schema_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_schema_resp__field_descriptors[1] = +{ + { + "schema_content", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetSchemaResp, schema_content), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_schema_resp__field_indices_by_name[] = { + 0, /* field[0] = schema_content */ +}; +static const ProtobufCIntRange sr__get_schema_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_schema_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetSchemaResp", + "GetSchemaResp", + "Sr__GetSchemaResp", + "sr", + sizeof(Sr__GetSchemaResp), + 1, + sr__get_schema_resp__field_descriptors, + sr__get_schema_resp__field_indices_by_name, + 1, sr__get_schema_resp__number_ranges, + (ProtobufCMessageInit) sr__get_schema_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_item_req__field_descriptors[1] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetItemReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_item_req__field_indices_by_name[] = { + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__get_item_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_item_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetItemReq", + "GetItemReq", + "Sr__GetItemReq", + "sr", + sizeof(Sr__GetItemReq), + 1, + sr__get_item_req__field_descriptors, + sr__get_item_req__field_indices_by_name, + 1, sr__get_item_req__number_ranges, + (ProtobufCMessageInit) sr__get_item_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_item_resp__field_descriptors[1] = +{ + { + "value", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__GetItemResp, value), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_item_resp__field_indices_by_name[] = { + 0, /* field[0] = value */ +}; +static const ProtobufCIntRange sr__get_item_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_item_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetItemResp", + "GetItemResp", + "Sr__GetItemResp", + "sr", + sizeof(Sr__GetItemResp), + 1, + sr__get_item_resp__field_descriptors, + sr__get_item_resp__field_indices_by_name, + 1, sr__get_item_resp__number_ranges, + (ProtobufCMessageInit) sr__get_item_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_items_req__field_descriptors[3] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetItemsReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "limit", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__GetItemsReq, has_limit), + offsetof(Sr__GetItemsReq, limit), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "offset", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__GetItemsReq, has_offset), + offsetof(Sr__GetItemsReq, offset), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_items_req__field_indices_by_name[] = { + 1, /* field[1] = limit */ + 2, /* field[2] = offset */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__get_items_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__get_items_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetItemsReq", + "GetItemsReq", + "Sr__GetItemsReq", + "sr", + sizeof(Sr__GetItemsReq), + 3, + sr__get_items_req__field_descriptors, + sr__get_items_req__field_indices_by_name, + 1, sr__get_items_req__number_ranges, + (ProtobufCMessageInit) sr__get_items_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_items_resp__field_descriptors[1] = +{ + { + "values", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__GetItemsResp, n_values), + offsetof(Sr__GetItemsResp, values), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_items_resp__field_indices_by_name[] = { + 0, /* field[0] = values */ +}; +static const ProtobufCIntRange sr__get_items_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_items_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetItemsResp", + "GetItemsResp", + "Sr__GetItemsResp", + "sr", + sizeof(Sr__GetItemsResp), + 1, + sr__get_items_resp__field_descriptors, + sr__get_items_resp__field_indices_by_name, + 1, sr__get_items_resp__number_ranges, + (ProtobufCMessageInit) sr__get_items_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_subtree_req__field_descriptors[1] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreeReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_subtree_req__field_indices_by_name[] = { + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__get_subtree_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_subtree_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetSubtreeReq", + "GetSubtreeReq", + "Sr__GetSubtreeReq", + "sr", + sizeof(Sr__GetSubtreeReq), + 1, + sr__get_subtree_req__field_descriptors, + sr__get_subtree_req__field_indices_by_name, + 1, sr__get_subtree_req__number_ranges, + (ProtobufCMessageInit) sr__get_subtree_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_subtree_resp__field_descriptors[1] = +{ + { + "tree", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreeResp, tree), + &sr__node__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_subtree_resp__field_indices_by_name[] = { + 0, /* field[0] = tree */ +}; +static const ProtobufCIntRange sr__get_subtree_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_subtree_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetSubtreeResp", + "GetSubtreeResp", + "Sr__GetSubtreeResp", + "sr", + sizeof(Sr__GetSubtreeResp), + 1, + sr__get_subtree_resp__field_descriptors, + sr__get_subtree_resp__field_indices_by_name, + 1, sr__get_subtree_resp__number_ranges, + (ProtobufCMessageInit) sr__get_subtree_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_subtrees_req__field_descriptors[1] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreesReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_subtrees_req__field_indices_by_name[] = { + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__get_subtrees_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_subtrees_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetSubtreesReq", + "GetSubtreesReq", + "Sr__GetSubtreesReq", + "sr", + sizeof(Sr__GetSubtreesReq), + 1, + sr__get_subtrees_req__field_descriptors, + sr__get_subtrees_req__field_indices_by_name, + 1, sr__get_subtrees_req__number_ranges, + (ProtobufCMessageInit) sr__get_subtrees_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_subtrees_resp__field_descriptors[1] = +{ + { + "trees", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__GetSubtreesResp, n_trees), + offsetof(Sr__GetSubtreesResp, trees), + &sr__node__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_subtrees_resp__field_indices_by_name[] = { + 0, /* field[0] = trees */ +}; +static const ProtobufCIntRange sr__get_subtrees_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_subtrees_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetSubtreesResp", + "GetSubtreesResp", + "Sr__GetSubtreesResp", + "sr", + sizeof(Sr__GetSubtreesResp), + 1, + sr__get_subtrees_resp__field_descriptors, + sr__get_subtrees_resp__field_indices_by_name, + 1, sr__get_subtrees_resp__number_ranges, + (ProtobufCMessageInit) sr__get_subtrees_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_subtree_chunk_req__field_descriptors[6] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreeChunkReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "single", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreeChunkReq, single), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "slice_offset", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreeChunkReq, slice_offset), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "slice_width", + 4, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreeChunkReq, slice_width), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "child_limit", + 5, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreeChunkReq, child_limit), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "depth_limit", + 6, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__GetSubtreeChunkReq, depth_limit), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_subtree_chunk_req__field_indices_by_name[] = { + 4, /* field[4] = child_limit */ + 5, /* field[5] = depth_limit */ + 1, /* field[1] = single */ + 2, /* field[2] = slice_offset */ + 3, /* field[3] = slice_width */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__get_subtree_chunk_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor sr__get_subtree_chunk_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetSubtreeChunkReq", + "GetSubtreeChunkReq", + "Sr__GetSubtreeChunkReq", + "sr", + sizeof(Sr__GetSubtreeChunkReq), + 6, + sr__get_subtree_chunk_req__field_descriptors, + sr__get_subtree_chunk_req__field_indices_by_name, + 1, sr__get_subtree_chunk_req__number_ranges, + (ProtobufCMessageInit) sr__get_subtree_chunk_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_subtree_chunk_resp__field_descriptors[2] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_STRING, + offsetof(Sr__GetSubtreeChunkResp, n_xpath), + offsetof(Sr__GetSubtreeChunkResp, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "chunk", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__GetSubtreeChunkResp, n_chunk), + offsetof(Sr__GetSubtreeChunkResp, chunk), + &sr__node__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_subtree_chunk_resp__field_indices_by_name[] = { + 1, /* field[1] = chunk */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__get_subtree_chunk_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor sr__get_subtree_chunk_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetSubtreeChunkResp", + "GetSubtreeChunkResp", + "Sr__GetSubtreeChunkResp", + "sr", + sizeof(Sr__GetSubtreeChunkResp), + 2, + sr__get_subtree_chunk_resp__field_descriptors, + sr__get_subtree_chunk_resp__field_indices_by_name, + 1, sr__get_subtree_chunk_resp__number_ranges, + (ProtobufCMessageInit) sr__get_subtree_chunk_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__set_item_req__field_descriptors[3] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SetItemReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "value", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__SetItemReq, value), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "options", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__SetItemReq, options), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__set_item_req__field_indices_by_name[] = { + 2, /* field[2] = options */ + 1, /* field[1] = value */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__set_item_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__set_item_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SetItemReq", + "SetItemReq", + "Sr__SetItemReq", + "sr", + sizeof(Sr__SetItemReq), + 3, + sr__set_item_req__field_descriptors, + sr__set_item_req__field_indices_by_name, + 1, sr__set_item_req__number_ranges, + (ProtobufCMessageInit) sr__set_item_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__set_item_resp__field_descriptors NULL +#define sr__set_item_resp__field_indices_by_name NULL +#define sr__set_item_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__set_item_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SetItemResp", + "SetItemResp", + "Sr__SetItemResp", + "sr", + sizeof(Sr__SetItemResp), + 0, + sr__set_item_resp__field_descriptors, + sr__set_item_resp__field_indices_by_name, + 0, sr__set_item_resp__number_ranges, + (ProtobufCMessageInit) sr__set_item_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__set_item_str_req__field_descriptors[3] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SetItemStrReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "value", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SetItemStrReq, value), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "options", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__SetItemStrReq, options), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__set_item_str_req__field_indices_by_name[] = { + 2, /* field[2] = options */ + 1, /* field[1] = value */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__set_item_str_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__set_item_str_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SetItemStrReq", + "SetItemStrReq", + "Sr__SetItemStrReq", + "sr", + sizeof(Sr__SetItemStrReq), + 3, + sr__set_item_str_req__field_descriptors, + sr__set_item_str_req__field_indices_by_name, + 1, sr__set_item_str_req__number_ranges, + (ProtobufCMessageInit) sr__set_item_str_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__set_item_str_resp__field_descriptors NULL +#define sr__set_item_str_resp__field_indices_by_name NULL +#define sr__set_item_str_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__set_item_str_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SetItemStrResp", + "SetItemStrResp", + "Sr__SetItemStrResp", + "sr", + sizeof(Sr__SetItemStrResp), + 0, + sr__set_item_str_resp__field_descriptors, + sr__set_item_str_resp__field_indices_by_name, + 0, sr__set_item_str_resp__number_ranges, + (ProtobufCMessageInit) sr__set_item_str_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__delete_item_req__field_descriptors[2] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__DeleteItemReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "options", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__DeleteItemReq, options), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__delete_item_req__field_indices_by_name[] = { + 1, /* field[1] = options */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__delete_item_req__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 3, 1 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor sr__delete_item_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.DeleteItemReq", + "DeleteItemReq", + "Sr__DeleteItemReq", + "sr", + sizeof(Sr__DeleteItemReq), + 2, + sr__delete_item_req__field_descriptors, + sr__delete_item_req__field_indices_by_name, + 2, sr__delete_item_req__number_ranges, + (ProtobufCMessageInit) sr__delete_item_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__delete_item_resp__field_descriptors NULL +#define sr__delete_item_resp__field_indices_by_name NULL +#define sr__delete_item_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__delete_item_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.DeleteItemResp", + "DeleteItemResp", + "Sr__DeleteItemResp", + "sr", + sizeof(Sr__DeleteItemResp), + 0, + sr__delete_item_resp__field_descriptors, + sr__delete_item_resp__field_indices_by_name, + 0, sr__delete_item_resp__number_ranges, + (ProtobufCMessageInit) sr__delete_item_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCEnumValue sr__move_item_req__move_position__enum_values_by_number[4] = +{ + { "BEFORE", "SR__MOVE_ITEM_REQ__MOVE_POSITION__BEFORE", 1 }, + { "AFTER", "SR__MOVE_ITEM_REQ__MOVE_POSITION__AFTER", 2 }, + { "FIRST", "SR__MOVE_ITEM_REQ__MOVE_POSITION__FIRST", 3 }, + { "LAST", "SR__MOVE_ITEM_REQ__MOVE_POSITION__LAST", 4 }, +}; +static const ProtobufCIntRange sr__move_item_req__move_position__value_ranges[] = { +{1, 0},{0, 4} +}; +static const ProtobufCEnumValueIndex sr__move_item_req__move_position__enum_values_by_name[4] = +{ + { "AFTER", 1 }, + { "BEFORE", 0 }, + { "FIRST", 2 }, + { "LAST", 3 }, +}; +const ProtobufCEnumDescriptor sr__move_item_req__move_position__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.MoveItemReq.MovePosition", + "MovePosition", + "Sr__MoveItemReq__MovePosition", + "sr", + 4, + sr__move_item_req__move_position__enum_values_by_number, + 4, + sr__move_item_req__move_position__enum_values_by_name, + 1, + sr__move_item_req__move_position__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor sr__move_item_req__field_descriptors[3] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__MoveItemReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "position", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__MoveItemReq, position), + &sr__move_item_req__move_position__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "relative_item", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__MoveItemReq, relative_item), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__move_item_req__field_indices_by_name[] = { + 1, /* field[1] = position */ + 2, /* field[2] = relative_item */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__move_item_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__move_item_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.MoveItemReq", + "MoveItemReq", + "Sr__MoveItemReq", + "sr", + sizeof(Sr__MoveItemReq), + 3, + sr__move_item_req__field_descriptors, + sr__move_item_req__field_indices_by_name, + 1, sr__move_item_req__number_ranges, + (ProtobufCMessageInit) sr__move_item_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__move_item_resp__field_descriptors NULL +#define sr__move_item_resp__field_indices_by_name NULL +#define sr__move_item_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__move_item_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.MoveItemResp", + "MoveItemResp", + "Sr__MoveItemResp", + "sr", + sizeof(Sr__MoveItemResp), + 0, + sr__move_item_resp__field_descriptors, + sr__move_item_resp__field_indices_by_name, + 0, sr__move_item_resp__number_ranges, + (ProtobufCMessageInit) sr__move_item_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__validate_req__field_descriptors NULL +#define sr__validate_req__field_indices_by_name NULL +#define sr__validate_req__number_ranges NULL +const ProtobufCMessageDescriptor sr__validate_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.ValidateReq", + "ValidateReq", + "Sr__ValidateReq", + "sr", + sizeof(Sr__ValidateReq), + 0, + sr__validate_req__field_descriptors, + sr__validate_req__field_indices_by_name, + 0, sr__validate_req__number_ranges, + (ProtobufCMessageInit) sr__validate_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__validate_resp__field_descriptors[1] = +{ + { + "errors", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__ValidateResp, n_errors), + offsetof(Sr__ValidateResp, errors), + &sr__error__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__validate_resp__field_indices_by_name[] = { + 0, /* field[0] = errors */ +}; +static const ProtobufCIntRange sr__validate_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__validate_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.ValidateResp", + "ValidateResp", + "Sr__ValidateResp", + "sr", + sizeof(Sr__ValidateResp), + 1, + sr__validate_resp__field_descriptors, + sr__validate_resp__field_indices_by_name, + 1, sr__validate_resp__number_ranges, + (ProtobufCMessageInit) sr__validate_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__commit_req__field_descriptors NULL +#define sr__commit_req__field_indices_by_name NULL +#define sr__commit_req__number_ranges NULL +const ProtobufCMessageDescriptor sr__commit_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CommitReq", + "CommitReq", + "Sr__CommitReq", + "sr", + sizeof(Sr__CommitReq), + 0, + sr__commit_req__field_descriptors, + sr__commit_req__field_indices_by_name, + 0, sr__commit_req__number_ranges, + (ProtobufCMessageInit) sr__commit_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__commit_resp__field_descriptors[1] = +{ + { + "errors", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__CommitResp, n_errors), + offsetof(Sr__CommitResp, errors), + &sr__error__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__commit_resp__field_indices_by_name[] = { + 0, /* field[0] = errors */ +}; +static const ProtobufCIntRange sr__commit_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__commit_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CommitResp", + "CommitResp", + "Sr__CommitResp", + "sr", + sizeof(Sr__CommitResp), + 1, + sr__commit_resp__field_descriptors, + sr__commit_resp__field_indices_by_name, + 1, sr__commit_resp__number_ranges, + (ProtobufCMessageInit) sr__commit_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__discard_changes_req__field_descriptors NULL +#define sr__discard_changes_req__field_indices_by_name NULL +#define sr__discard_changes_req__number_ranges NULL +const ProtobufCMessageDescriptor sr__discard_changes_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.DiscardChangesReq", + "DiscardChangesReq", + "Sr__DiscardChangesReq", + "sr", + sizeof(Sr__DiscardChangesReq), + 0, + sr__discard_changes_req__field_descriptors, + sr__discard_changes_req__field_indices_by_name, + 0, sr__discard_changes_req__number_ranges, + (ProtobufCMessageInit) sr__discard_changes_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__discard_changes_resp__field_descriptors NULL +#define sr__discard_changes_resp__field_indices_by_name NULL +#define sr__discard_changes_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__discard_changes_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.DiscardChangesResp", + "DiscardChangesResp", + "Sr__DiscardChangesResp", + "sr", + sizeof(Sr__DiscardChangesResp), + 0, + sr__discard_changes_resp__field_descriptors, + sr__discard_changes_resp__field_indices_by_name, + 0, sr__discard_changes_resp__number_ranges, + (ProtobufCMessageInit) sr__discard_changes_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__copy_config_req__field_descriptors[3] = +{ + { + "src_datastore", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__CopyConfigReq, src_datastore), + &sr__data_store__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dst_datastore", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__CopyConfigReq, dst_datastore), + &sr__data_store__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_name", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__CopyConfigReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__copy_config_req__field_indices_by_name[] = { + 1, /* field[1] = dst_datastore */ + 2, /* field[2] = module_name */ + 0, /* field[0] = src_datastore */ +}; +static const ProtobufCIntRange sr__copy_config_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__copy_config_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CopyConfigReq", + "CopyConfigReq", + "Sr__CopyConfigReq", + "sr", + sizeof(Sr__CopyConfigReq), + 3, + sr__copy_config_req__field_descriptors, + sr__copy_config_req__field_indices_by_name, + 1, sr__copy_config_req__number_ranges, + (ProtobufCMessageInit) sr__copy_config_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__copy_config_resp__field_descriptors[1] = +{ + { + "errors", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__CopyConfigResp, n_errors), + offsetof(Sr__CopyConfigResp, errors), + &sr__error__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__copy_config_resp__field_indices_by_name[] = { + 0, /* field[0] = errors */ +}; +static const ProtobufCIntRange sr__copy_config_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__copy_config_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CopyConfigResp", + "CopyConfigResp", + "Sr__CopyConfigResp", + "sr", + sizeof(Sr__CopyConfigResp), + 1, + sr__copy_config_resp__field_descriptors, + sr__copy_config_resp__field_indices_by_name, + 1, sr__copy_config_resp__number_ranges, + (ProtobufCMessageInit) sr__copy_config_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__lock_req__field_descriptors[1] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__LockReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__lock_req__field_indices_by_name[] = { + 0, /* field[0] = module_name */ +}; +static const ProtobufCIntRange sr__lock_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__lock_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.LockReq", + "LockReq", + "Sr__LockReq", + "sr", + sizeof(Sr__LockReq), + 1, + sr__lock_req__field_descriptors, + sr__lock_req__field_indices_by_name, + 1, sr__lock_req__number_ranges, + (ProtobufCMessageInit) sr__lock_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__lock_resp__field_descriptors NULL +#define sr__lock_resp__field_indices_by_name NULL +#define sr__lock_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__lock_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.LockResp", + "LockResp", + "Sr__LockResp", + "sr", + sizeof(Sr__LockResp), + 0, + sr__lock_resp__field_descriptors, + sr__lock_resp__field_indices_by_name, + 0, sr__lock_resp__number_ranges, + (ProtobufCMessageInit) sr__lock_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__unlock_req__field_descriptors[1] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__UnlockReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__unlock_req__field_indices_by_name[] = { + 0, /* field[0] = module_name */ +}; +static const ProtobufCIntRange sr__unlock_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__unlock_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.UnlockReq", + "UnlockReq", + "Sr__UnlockReq", + "sr", + sizeof(Sr__UnlockReq), + 1, + sr__unlock_req__field_descriptors, + sr__unlock_req__field_indices_by_name, + 1, sr__unlock_req__number_ranges, + (ProtobufCMessageInit) sr__unlock_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__unlock_resp__field_descriptors NULL +#define sr__unlock_resp__field_indices_by_name NULL +#define sr__unlock_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__unlock_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.UnlockResp", + "UnlockResp", + "Sr__UnlockResp", + "sr", + sizeof(Sr__UnlockResp), + 0, + sr__unlock_resp__field_descriptors, + sr__unlock_resp__field_indices_by_name, + 0, sr__unlock_resp__number_ranges, + (ProtobufCMessageInit) sr__unlock_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__subscribe_req__field_descriptors[10] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__SubscribeReq, type), + &sr__subscription_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "destination", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SubscribeReq, destination), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscription_id", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__SubscribeReq, subscription_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_name", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SubscribeReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "xpath", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SubscribeReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "notif_event", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(Sr__SubscribeReq, has_notif_event), + offsetof(Sr__SubscribeReq, notif_event), + &sr__notification_event__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "priority", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__SubscribeReq, has_priority), + offsetof(Sr__SubscribeReq, priority), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enable_running", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(Sr__SubscribeReq, has_enable_running), + offsetof(Sr__SubscribeReq, enable_running), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enable_event", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(Sr__SubscribeReq, has_enable_event), + offsetof(Sr__SubscribeReq, enable_event), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "api_variant", + 20, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__SubscribeReq, api_variant), + &sr__api_variant__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__subscribe_req__field_indices_by_name[] = { + 9, /* field[9] = api_variant */ + 1, /* field[1] = destination */ + 8, /* field[8] = enable_event */ + 7, /* field[7] = enable_running */ + 3, /* field[3] = module_name */ + 5, /* field[5] = notif_event */ + 6, /* field[6] = priority */ + 2, /* field[2] = subscription_id */ + 0, /* field[0] = type */ + 4, /* field[4] = xpath */ +}; +static const ProtobufCIntRange sr__subscribe_req__number_ranges[3 + 1] = +{ + { 1, 0 }, + { 10, 5 }, + { 20, 9 }, + { 0, 10 } +}; +const ProtobufCMessageDescriptor sr__subscribe_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SubscribeReq", + "SubscribeReq", + "Sr__SubscribeReq", + "sr", + sizeof(Sr__SubscribeReq), + 10, + sr__subscribe_req__field_descriptors, + sr__subscribe_req__field_indices_by_name, + 3, sr__subscribe_req__number_ranges, + (ProtobufCMessageInit) sr__subscribe_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__subscribe_resp__field_descriptors NULL +#define sr__subscribe_resp__field_indices_by_name NULL +#define sr__subscribe_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__subscribe_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SubscribeResp", + "SubscribeResp", + "Sr__SubscribeResp", + "sr", + sizeof(Sr__SubscribeResp), + 0, + sr__subscribe_resp__field_descriptors, + sr__subscribe_resp__field_indices_by_name, + 0, sr__subscribe_resp__number_ranges, + (ProtobufCMessageInit) sr__subscribe_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__unsubscribe_req__field_descriptors[4] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__UnsubscribeReq, type), + &sr__subscription_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "destination", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__UnsubscribeReq, destination), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscription_id", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__UnsubscribeReq, subscription_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_name", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__UnsubscribeReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__unsubscribe_req__field_indices_by_name[] = { + 1, /* field[1] = destination */ + 3, /* field[3] = module_name */ + 2, /* field[2] = subscription_id */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange sr__unsubscribe_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor sr__unsubscribe_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.UnsubscribeReq", + "UnsubscribeReq", + "Sr__UnsubscribeReq", + "sr", + sizeof(Sr__UnsubscribeReq), + 4, + sr__unsubscribe_req__field_descriptors, + sr__unsubscribe_req__field_indices_by_name, + 1, sr__unsubscribe_req__number_ranges, + (ProtobufCMessageInit) sr__unsubscribe_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__unsubscribe_resp__field_descriptors NULL +#define sr__unsubscribe_resp__field_indices_by_name NULL +#define sr__unsubscribe_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__unsubscribe_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.UnsubscribeResp", + "UnsubscribeResp", + "Sr__UnsubscribeResp", + "sr", + sizeof(Sr__UnsubscribeResp), + 0, + sr__unsubscribe_resp__field_descriptors, + sr__unsubscribe_resp__field_indices_by_name, + 0, sr__unsubscribe_resp__number_ranges, + (ProtobufCMessageInit) sr__unsubscribe_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__check_enabled_running_req__field_descriptors[1] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__CheckEnabledRunningReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__check_enabled_running_req__field_indices_by_name[] = { + 0, /* field[0] = module_name */ +}; +static const ProtobufCIntRange sr__check_enabled_running_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__check_enabled_running_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CheckEnabledRunningReq", + "CheckEnabledRunningReq", + "Sr__CheckEnabledRunningReq", + "sr", + sizeof(Sr__CheckEnabledRunningReq), + 1, + sr__check_enabled_running_req__field_descriptors, + sr__check_enabled_running_req__field_indices_by_name, + 1, sr__check_enabled_running_req__number_ranges, + (ProtobufCMessageInit) sr__check_enabled_running_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__check_enabled_running_resp__field_descriptors[1] = +{ + { + "enabled", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__CheckEnabledRunningResp, enabled), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__check_enabled_running_resp__field_indices_by_name[] = { + 0, /* field[0] = enabled */ +}; +static const ProtobufCIntRange sr__check_enabled_running_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__check_enabled_running_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CheckEnabledRunningResp", + "CheckEnabledRunningResp", + "Sr__CheckEnabledRunningResp", + "sr", + sizeof(Sr__CheckEnabledRunningResp), + 1, + sr__check_enabled_running_resp__field_descriptors, + sr__check_enabled_running_resp__field_indices_by_name, + 1, sr__check_enabled_running_resp__number_ranges, + (ProtobufCMessageInit) sr__check_enabled_running_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__module_install_notification__field_descriptors[3] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleInstallNotification, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "revision", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleInstallNotification, revision), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "state", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleInstallNotification, state), + &sr__module_state__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__module_install_notification__field_indices_by_name[] = { + 0, /* field[0] = module_name */ + 1, /* field[1] = revision */ + 2, /* field[2] = state */ +}; +static const ProtobufCIntRange sr__module_install_notification__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__module_install_notification__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.ModuleInstallNotification", + "ModuleInstallNotification", + "Sr__ModuleInstallNotification", + "sr", + sizeof(Sr__ModuleInstallNotification), + 3, + sr__module_install_notification__field_descriptors, + sr__module_install_notification__field_indices_by_name, + 1, sr__module_install_notification__number_ranges, + (ProtobufCMessageInit) sr__module_install_notification__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__feature_enable_notification__field_descriptors[3] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__FeatureEnableNotification, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "feature_name", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__FeatureEnableNotification, feature_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enabled", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__FeatureEnableNotification, enabled), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__feature_enable_notification__field_indices_by_name[] = { + 2, /* field[2] = enabled */ + 1, /* field[1] = feature_name */ + 0, /* field[0] = module_name */ +}; +static const ProtobufCIntRange sr__feature_enable_notification__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__feature_enable_notification__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.FeatureEnableNotification", + "FeatureEnableNotification", + "Sr__FeatureEnableNotification", + "sr", + sizeof(Sr__FeatureEnableNotification), + 3, + sr__feature_enable_notification__field_descriptors, + sr__feature_enable_notification__field_indices_by_name, + 1, sr__feature_enable_notification__number_ranges, + (ProtobufCMessageInit) sr__feature_enable_notification__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__module_change_notification__field_descriptors[2] = +{ + { + "event", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleChangeNotification, event), + &sr__notification_event__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_name", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleChangeNotification, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__module_change_notification__field_indices_by_name[] = { + 0, /* field[0] = event */ + 1, /* field[1] = module_name */ +}; +static const ProtobufCIntRange sr__module_change_notification__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor sr__module_change_notification__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.ModuleChangeNotification", + "ModuleChangeNotification", + "Sr__ModuleChangeNotification", + "sr", + sizeof(Sr__ModuleChangeNotification), + 2, + sr__module_change_notification__field_descriptors, + sr__module_change_notification__field_indices_by_name, + 1, sr__module_change_notification__number_ranges, + (ProtobufCMessageInit) sr__module_change_notification__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__subtree_change_notification__field_descriptors[2] = +{ + { + "event", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__SubtreeChangeNotification, event), + &sr__notification_event__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "xpath", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__SubtreeChangeNotification, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__subtree_change_notification__field_indices_by_name[] = { + 0, /* field[0] = event */ + 1, /* field[1] = xpath */ +}; +static const ProtobufCIntRange sr__subtree_change_notification__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor sr__subtree_change_notification__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.SubtreeChangeNotification", + "SubtreeChangeNotification", + "Sr__SubtreeChangeNotification", + "sr", + sizeof(Sr__SubtreeChangeNotification), + 2, + sr__subtree_change_notification__field_descriptors, + sr__subtree_change_notification__field_indices_by_name, + 1, sr__subtree_change_notification__number_ranges, + (ProtobufCMessageInit) sr__subtree_change_notification__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__change__field_descriptors[3] = +{ + { + "changeOperation", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__Change, changeoperation), + &sr__change_operation__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "new_value", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Change, new_value), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "old_value", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Change, old_value), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__change__field_indices_by_name[] = { + 0, /* field[0] = changeOperation */ + 1, /* field[1] = new_value */ + 2, /* field[2] = old_value */ +}; +static const ProtobufCIntRange sr__change__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__change__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Change", + "Change", + "Sr__Change", + "sr", + sizeof(Sr__Change), + 3, + sr__change__field_descriptors, + sr__change__field_indices_by_name, + 1, sr__change__number_ranges, + (ProtobufCMessageInit) sr__change__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_changes_req__field_descriptors[3] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__GetChangesReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "limit", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__GetChangesReq, limit), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "offset", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__GetChangesReq, offset), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_changes_req__field_indices_by_name[] = { + 1, /* field[1] = limit */ + 2, /* field[2] = offset */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__get_changes_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__get_changes_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetChangesReq", + "GetChangesReq", + "Sr__GetChangesReq", + "sr", + sizeof(Sr__GetChangesReq), + 3, + sr__get_changes_req__field_descriptors, + sr__get_changes_req__field_indices_by_name, + 1, sr__get_changes_req__number_ranges, + (ProtobufCMessageInit) sr__get_changes_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__get_changes_resp__field_descriptors[1] = +{ + { + "changes", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__GetChangesResp, n_changes), + offsetof(Sr__GetChangesResp, changes), + &sr__change__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__get_changes_resp__field_indices_by_name[] = { + 0, /* field[0] = changes */ +}; +static const ProtobufCIntRange sr__get_changes_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__get_changes_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.GetChangesResp", + "GetChangesResp", + "Sr__GetChangesResp", + "sr", + sizeof(Sr__GetChangesResp), + 1, + sr__get_changes_resp__field_descriptors, + sr__get_changes_resp__field_indices_by_name, + 1, sr__get_changes_resp__number_ranges, + (ProtobufCMessageInit) sr__get_changes_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__check_exec_perm_req__field_descriptors[1] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__CheckExecPermReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__check_exec_perm_req__field_indices_by_name[] = { + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__check_exec_perm_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__check_exec_perm_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CheckExecPermReq", + "CheckExecPermReq", + "Sr__CheckExecPermReq", + "sr", + sizeof(Sr__CheckExecPermReq), + 1, + sr__check_exec_perm_req__field_descriptors, + sr__check_exec_perm_req__field_indices_by_name, + 1, sr__check_exec_perm_req__number_ranges, + (ProtobufCMessageInit) sr__check_exec_perm_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__check_exec_perm_resp__field_descriptors[1] = +{ + { + "permitted", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__CheckExecPermResp, permitted), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__check_exec_perm_resp__field_indices_by_name[] = { + 0, /* field[0] = permitted */ +}; +static const ProtobufCIntRange sr__check_exec_perm_resp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__check_exec_perm_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CheckExecPermResp", + "CheckExecPermResp", + "Sr__CheckExecPermResp", + "sr", + sizeof(Sr__CheckExecPermResp), + 1, + sr__check_exec_perm_resp__field_descriptors, + sr__check_exec_perm_resp__field_indices_by_name, + 1, sr__check_exec_perm_resp__number_ranges, + (ProtobufCMessageInit) sr__check_exec_perm_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__rpcreq__field_descriptors[7] = +{ + { + "action", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__RPCReq, action), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "xpath", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__RPCReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "orig_api_variant", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__RPCReq, orig_api_variant), + &sr__api_variant__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "input", + 4, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__RPCReq, n_input), + offsetof(Sr__RPCReq, input), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "input_tree", + 5, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__RPCReq, n_input_tree), + offsetof(Sr__RPCReq, input_tree), + &sr__node__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscriber_address", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__RPCReq, subscriber_address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscription_id", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__RPCReq, has_subscription_id), + offsetof(Sr__RPCReq, subscription_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__rpcreq__field_indices_by_name[] = { + 0, /* field[0] = action */ + 3, /* field[3] = input */ + 4, /* field[4] = input_tree */ + 2, /* field[2] = orig_api_variant */ + 5, /* field[5] = subscriber_address */ + 6, /* field[6] = subscription_id */ + 1, /* field[1] = xpath */ +}; +static const ProtobufCIntRange sr__rpcreq__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 10, 5 }, + { 0, 7 } +}; +const ProtobufCMessageDescriptor sr__rpcreq__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.RPCReq", + "RPCReq", + "Sr__RPCReq", + "sr", + sizeof(Sr__RPCReq), + 7, + sr__rpcreq__field_descriptors, + sr__rpcreq__field_indices_by_name, + 2, sr__rpcreq__number_ranges, + (ProtobufCMessageInit) sr__rpcreq__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__rpcresp__field_descriptors[5] = +{ + { + "action", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__RPCResp, action), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "xpath", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__RPCResp, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "orig_api_variant", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__RPCResp, orig_api_variant), + &sr__api_variant__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "output", + 4, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__RPCResp, n_output), + offsetof(Sr__RPCResp, output), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "output_tree", + 5, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__RPCResp, n_output_tree), + offsetof(Sr__RPCResp, output_tree), + &sr__node__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__rpcresp__field_indices_by_name[] = { + 0, /* field[0] = action */ + 2, /* field[2] = orig_api_variant */ + 3, /* field[3] = output */ + 4, /* field[4] = output_tree */ + 1, /* field[1] = xpath */ +}; +static const ProtobufCIntRange sr__rpcresp__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor sr__rpcresp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.RPCResp", + "RPCResp", + "Sr__RPCResp", + "sr", + sizeof(Sr__RPCResp), + 5, + sr__rpcresp__field_descriptors, + sr__rpcresp__field_indices_by_name, + 1, sr__rpcresp__number_ranges, + (ProtobufCMessageInit) sr__rpcresp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCEnumValue sr__event_notif_req__notif_type__enum_values_by_number[4] = +{ + { "REALTIME", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REALTIME", 1 }, + { "REPLAY", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY", 2 }, + { "REPLAY_COMPLETE", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_COMPLETE", 3 }, + { "REPLAY_STOP", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_STOP", 4 }, +}; +static const ProtobufCIntRange sr__event_notif_req__notif_type__value_ranges[] = { +{1, 0},{0, 4} +}; +static const ProtobufCEnumValueIndex sr__event_notif_req__notif_type__enum_values_by_name[4] = +{ + { "REALTIME", 0 }, + { "REPLAY", 1 }, + { "REPLAY_COMPLETE", 2 }, + { "REPLAY_STOP", 3 }, +}; +const ProtobufCEnumDescriptor sr__event_notif_req__notif_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.EventNotifReq.NotifType", + "NotifType", + "Sr__EventNotifReq__NotifType", + "sr", + 4, + sr__event_notif_req__notif_type__enum_values_by_number, + 4, + sr__event_notif_req__notif_type__enum_values_by_name, + 1, + sr__event_notif_req__notif_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__event_notif_req__notif_flags__enum_values_by_number[2] = +{ + { "DEFAULT", "SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__DEFAULT", 0 }, + { "EPHEMERAL", "SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__EPHEMERAL", 1 }, +}; +static const ProtobufCIntRange sr__event_notif_req__notif_flags__value_ranges[] = { +{0, 0},{0, 2} +}; +static const ProtobufCEnumValueIndex sr__event_notif_req__notif_flags__enum_values_by_name[2] = +{ + { "DEFAULT", 0 }, + { "EPHEMERAL", 1 }, +}; +const ProtobufCEnumDescriptor sr__event_notif_req__notif_flags__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.EventNotifReq.NotifFlags", + "NotifFlags", + "Sr__EventNotifReq__NotifFlags", + "sr", + 2, + sr__event_notif_req__notif_flags__enum_values_by_number, + 2, + sr__event_notif_req__notif_flags__enum_values_by_name, + 1, + sr__event_notif_req__notif_flags__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor sr__event_notif_req__field_descriptors[9] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReq, type), + &sr__event_notif_req__notif_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "options", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReq, options), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "xpath", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "values", + 4, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__EventNotifReq, n_values), + offsetof(Sr__EventNotifReq, values), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "trees", + 5, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__EventNotifReq, n_trees), + offsetof(Sr__EventNotifReq, trees), + &sr__node__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "timestamp", + 6, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReq, timestamp), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscriber_address", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReq, subscriber_address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscription_id", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__EventNotifReq, has_subscription_id), + offsetof(Sr__EventNotifReq, subscription_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "do_not_send_reply", + 20, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReq, do_not_send_reply), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__event_notif_req__field_indices_by_name[] = { + 8, /* field[8] = do_not_send_reply */ + 1, /* field[1] = options */ + 6, /* field[6] = subscriber_address */ + 7, /* field[7] = subscription_id */ + 5, /* field[5] = timestamp */ + 4, /* field[4] = trees */ + 0, /* field[0] = type */ + 3, /* field[3] = values */ + 2, /* field[2] = xpath */ +}; +static const ProtobufCIntRange sr__event_notif_req__number_ranges[3 + 1] = +{ + { 1, 0 }, + { 10, 6 }, + { 20, 8 }, + { 0, 9 } +}; +const ProtobufCMessageDescriptor sr__event_notif_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.EventNotifReq", + "EventNotifReq", + "Sr__EventNotifReq", + "sr", + sizeof(Sr__EventNotifReq), + 9, + sr__event_notif_req__field_descriptors, + sr__event_notif_req__field_indices_by_name, + 3, sr__event_notif_req__number_ranges, + (ProtobufCMessageInit) sr__event_notif_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__event_notif_resp__field_descriptors NULL +#define sr__event_notif_resp__field_indices_by_name NULL +#define sr__event_notif_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__event_notif_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.EventNotifResp", + "EventNotifResp", + "Sr__EventNotifResp", + "sr", + sizeof(Sr__EventNotifResp), + 0, + sr__event_notif_resp__field_descriptors, + sr__event_notif_resp__field_indices_by_name, + 0, sr__event_notif_resp__number_ranges, + (ProtobufCMessageInit) sr__event_notif_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__event_notif_replay_req__field_descriptors[6] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReplayReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "start_time", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReplayReq, start_time), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "stop_time", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReplayReq, stop_time), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscriber_address", + 10, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReplayReq, subscriber_address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscription_id", + 11, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReplayReq, subscription_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "api_variant", + 12, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__EventNotifReplayReq, api_variant), + &sr__api_variant__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__event_notif_replay_req__field_indices_by_name[] = { + 5, /* field[5] = api_variant */ + 1, /* field[1] = start_time */ + 2, /* field[2] = stop_time */ + 3, /* field[3] = subscriber_address */ + 4, /* field[4] = subscription_id */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__event_notif_replay_req__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 10, 3 }, + { 0, 6 } +}; +const ProtobufCMessageDescriptor sr__event_notif_replay_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.EventNotifReplayReq", + "EventNotifReplayReq", + "Sr__EventNotifReplayReq", + "sr", + sizeof(Sr__EventNotifReplayReq), + 6, + sr__event_notif_replay_req__field_descriptors, + sr__event_notif_replay_req__field_indices_by_name, + 2, sr__event_notif_replay_req__number_ranges, + (ProtobufCMessageInit) sr__event_notif_replay_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__event_notif_replay_resp__field_descriptors NULL +#define sr__event_notif_replay_resp__field_indices_by_name NULL +#define sr__event_notif_replay_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__event_notif_replay_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.EventNotifReplayResp", + "EventNotifReplayResp", + "Sr__EventNotifReplayResp", + "sr", + sizeof(Sr__EventNotifReplayResp), + 0, + sr__event_notif_replay_resp__field_descriptors, + sr__event_notif_replay_resp__field_indices_by_name, + 0, sr__event_notif_replay_resp__number_ranges, + (ProtobufCMessageInit) sr__event_notif_replay_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__data_provide_req__field_descriptors[4] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__DataProvideReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscriber_address", + 10, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__DataProvideReq, subscriber_address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscription_id", + 11, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__DataProvideReq, subscription_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "request_id", + 20, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__DataProvideReq, request_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__data_provide_req__field_indices_by_name[] = { + 3, /* field[3] = request_id */ + 1, /* field[1] = subscriber_address */ + 2, /* field[2] = subscription_id */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__data_provide_req__number_ranges[3 + 1] = +{ + { 1, 0 }, + { 10, 1 }, + { 20, 3 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor sr__data_provide_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.DataProvideReq", + "DataProvideReq", + "Sr__DataProvideReq", + "sr", + sizeof(Sr__DataProvideReq), + 4, + sr__data_provide_req__field_descriptors, + sr__data_provide_req__field_indices_by_name, + 3, sr__data_provide_req__number_ranges, + (ProtobufCMessageInit) sr__data_provide_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__data_provide_resp__field_descriptors[3] = +{ + { + "xpath", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__DataProvideResp, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "values", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sr__DataProvideResp, n_values), + offsetof(Sr__DataProvideResp, values), + &sr__value__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "request_id", + 10, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__DataProvideResp, request_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__data_provide_resp__field_indices_by_name[] = { + 2, /* field[2] = request_id */ + 1, /* field[1] = values */ + 0, /* field[0] = xpath */ +}; +static const ProtobufCIntRange sr__data_provide_resp__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 10, 2 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__data_provide_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.DataProvideResp", + "DataProvideResp", + "Sr__DataProvideResp", + "sr", + sizeof(Sr__DataProvideResp), + 3, + sr__data_provide_resp__field_descriptors, + sr__data_provide_resp__field_indices_by_name, + 2, sr__data_provide_resp__number_ranges, + (ProtobufCMessageInit) sr__data_provide_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__module_install_req__field_descriptors[4] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleInstallReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "revision", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleInstallReq, revision), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "file_name", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleInstallReq, file_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "installed", + 4, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__ModuleInstallReq, installed), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__module_install_req__field_indices_by_name[] = { + 2, /* field[2] = file_name */ + 3, /* field[3] = installed */ + 0, /* field[0] = module_name */ + 1, /* field[1] = revision */ +}; +static const ProtobufCIntRange sr__module_install_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor sr__module_install_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.ModuleInstallReq", + "ModuleInstallReq", + "Sr__ModuleInstallReq", + "sr", + sizeof(Sr__ModuleInstallReq), + 4, + sr__module_install_req__field_descriptors, + sr__module_install_req__field_indices_by_name, + 1, sr__module_install_req__number_ranges, + (ProtobufCMessageInit) sr__module_install_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__module_install_resp__field_descriptors NULL +#define sr__module_install_resp__field_indices_by_name NULL +#define sr__module_install_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__module_install_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.ModuleInstallResp", + "ModuleInstallResp", + "Sr__ModuleInstallResp", + "sr", + sizeof(Sr__ModuleInstallResp), + 0, + sr__module_install_resp__field_descriptors, + sr__module_install_resp__field_indices_by_name, + 0, sr__module_install_resp__number_ranges, + (ProtobufCMessageInit) sr__module_install_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__feature_enable_req__field_descriptors[3] = +{ + { + "module_name", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__FeatureEnableReq, module_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "feature_name", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__FeatureEnableReq, feature_name), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "enabled", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__FeatureEnableReq, enabled), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__feature_enable_req__field_indices_by_name[] = { + 2, /* field[2] = enabled */ + 1, /* field[1] = feature_name */ + 0, /* field[0] = module_name */ +}; +static const ProtobufCIntRange sr__feature_enable_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sr__feature_enable_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.FeatureEnableReq", + "FeatureEnableReq", + "Sr__FeatureEnableReq", + "sr", + sizeof(Sr__FeatureEnableReq), + 3, + sr__feature_enable_req__field_descriptors, + sr__feature_enable_req__field_indices_by_name, + 1, sr__feature_enable_req__number_ranges, + (ProtobufCMessageInit) sr__feature_enable_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__feature_enable_resp__field_descriptors NULL +#define sr__feature_enable_resp__field_indices_by_name NULL +#define sr__feature_enable_resp__number_ranges NULL +const ProtobufCMessageDescriptor sr__feature_enable_resp__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.FeatureEnableResp", + "FeatureEnableResp", + "Sr__FeatureEnableResp", + "sr", + sizeof(Sr__FeatureEnableResp), + 0, + sr__feature_enable_resp__field_descriptors, + sr__feature_enable_resp__field_indices_by_name, + 0, sr__feature_enable_resp__number_ranges, + (ProtobufCMessageInit) sr__feature_enable_resp__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__unsubscribe_destination_req__field_descriptors[1] = +{ + { + "destination", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__UnsubscribeDestinationReq, destination), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__unsubscribe_destination_req__field_indices_by_name[] = { + 0, /* field[0] = destination */ +}; +static const ProtobufCIntRange sr__unsubscribe_destination_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__unsubscribe_destination_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.UnsubscribeDestinationReq", + "UnsubscribeDestinationReq", + "Sr__UnsubscribeDestinationReq", + "sr", + sizeof(Sr__UnsubscribeDestinationReq), + 1, + sr__unsubscribe_destination_req__field_descriptors, + sr__unsubscribe_destination_req__field_indices_by_name, + 1, sr__unsubscribe_destination_req__number_ranges, + (ProtobufCMessageInit) sr__unsubscribe_destination_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__commit_timeout_req__field_descriptors[2] = +{ + { + "commit_id", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__CommitTimeoutReq, commit_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "expired", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__CommitTimeoutReq, expired), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__commit_timeout_req__field_indices_by_name[] = { + 0, /* field[0] = commit_id */ + 1, /* field[1] = expired */ +}; +static const ProtobufCIntRange sr__commit_timeout_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor sr__commit_timeout_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.CommitTimeoutReq", + "CommitTimeoutReq", + "Sr__CommitTimeoutReq", + "sr", + sizeof(Sr__CommitTimeoutReq), + 2, + sr__commit_timeout_req__field_descriptors, + sr__commit_timeout_req__field_indices_by_name, + 1, sr__commit_timeout_req__number_ranges, + (ProtobufCMessageInit) sr__commit_timeout_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__oper_data_timeout_req__field_descriptors[1] = +{ + { + "request_id", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__OperDataTimeoutReq, request_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__oper_data_timeout_req__field_indices_by_name[] = { + 0, /* field[0] = request_id */ +}; +static const ProtobufCIntRange sr__oper_data_timeout_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__oper_data_timeout_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.OperDataTimeoutReq", + "OperDataTimeoutReq", + "Sr__OperDataTimeoutReq", + "sr", + sizeof(Sr__OperDataTimeoutReq), + 1, + sr__oper_data_timeout_req__field_descriptors, + sr__oper_data_timeout_req__field_indices_by_name, + 1, sr__oper_data_timeout_req__number_ranges, + (ProtobufCMessageInit) sr__oper_data_timeout_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__internal_state_data_req__field_descriptors[2] = +{ + { + "request_id", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__InternalStateDataReq, request_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "xpath", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__InternalStateDataReq, xpath), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__internal_state_data_req__field_indices_by_name[] = { + 0, /* field[0] = request_id */ + 1, /* field[1] = xpath */ +}; +static const ProtobufCIntRange sr__internal_state_data_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor sr__internal_state_data_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.InternalStateDataReq", + "InternalStateDataReq", + "Sr__InternalStateDataReq", + "sr", + sizeof(Sr__InternalStateDataReq), + 2, + sr__internal_state_data_req__field_descriptors, + sr__internal_state_data_req__field_indices_by_name, + 1, sr__internal_state_data_req__number_ranges, + (ProtobufCMessageInit) sr__internal_state_data_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__notif_store_cleanup_req__field_descriptors NULL +#define sr__notif_store_cleanup_req__field_indices_by_name NULL +#define sr__notif_store_cleanup_req__number_ranges NULL +const ProtobufCMessageDescriptor sr__notif_store_cleanup_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.NotifStoreCleanupReq", + "NotifStoreCleanupReq", + "Sr__NotifStoreCleanupReq", + "sr", + sizeof(Sr__NotifStoreCleanupReq), + 0, + sr__notif_store_cleanup_req__field_descriptors, + sr__notif_store_cleanup_req__field_indices_by_name, + 0, sr__notif_store_cleanup_req__number_ranges, + (ProtobufCMessageInit) sr__notif_store_cleanup_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__delayed_msg_req__field_descriptors[1] = +{ + { + "message", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__DelayedMsgReq, message), + &sr__msg__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__delayed_msg_req__field_indices_by_name[] = { + 0, /* field[0] = message */ +}; +static const ProtobufCIntRange sr__delayed_msg_req__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor sr__delayed_msg_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.DelayedMsgReq", + "DelayedMsgReq", + "Sr__DelayedMsgReq", + "sr", + sizeof(Sr__DelayedMsgReq), + 1, + sr__delayed_msg_req__field_descriptors, + sr__delayed_msg_req__field_indices_by_name, + 1, sr__delayed_msg_req__number_ranges, + (ProtobufCMessageInit) sr__delayed_msg_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define sr__nacm_reload_req__field_descriptors NULL +#define sr__nacm_reload_req__field_indices_by_name NULL +#define sr__nacm_reload_req__number_ranges NULL +const ProtobufCMessageDescriptor sr__nacm_reload_req__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.NacmReloadReq", + "NacmReloadReq", + "Sr__NacmReloadReq", + "sr", + sizeof(Sr__NacmReloadReq), + 0, + sr__nacm_reload_req__field_descriptors, + sr__nacm_reload_req__field_indices_by_name, + 0, sr__nacm_reload_req__number_ranges, + (ProtobufCMessageInit) sr__nacm_reload_req__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__request__field_descriptors[37] = +{ + { + "_id", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__Request, _id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "operation", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__Request, operation), + &sr__operation__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_start_req", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, session_start_req), + &sr__session_start_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_stop_req", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, session_stop_req), + &sr__session_stop_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_refresh_req", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, session_refresh_req), + &sr__session_refresh_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_check_req", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, session_check_req), + &sr__session_check_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_switch_ds_req", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, session_switch_ds_req), + &sr__session_switch_ds_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_set_opts_req", + 15, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, session_set_opts_req), + &sr__session_set_opts_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "version_verify_req", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, version_verify_req), + &sr__version_verify_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "list_schemas_req", + 20, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, list_schemas_req), + &sr__list_schemas_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_schema_req", + 21, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, get_schema_req), + &sr__get_schema_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_install_req", + 22, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, module_install_req), + &sr__module_install_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "feature_enable_req", + 23, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, feature_enable_req), + &sr__feature_enable_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_item_req", + 30, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, get_item_req), + &sr__get_item_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_items_req", + 31, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, get_items_req), + &sr__get_items_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_subtree_req", + 32, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, get_subtree_req), + &sr__get_subtree_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_subtrees_req", + 33, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, get_subtrees_req), + &sr__get_subtrees_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_subtree_chunk_req", + 34, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, get_subtree_chunk_req), + &sr__get_subtree_chunk_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "set_item_req", + 40, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, set_item_req), + &sr__set_item_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "delete_item_req", + 41, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, delete_item_req), + &sr__delete_item_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "move_item_req", + 42, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, move_item_req), + &sr__move_item_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "set_item_str_req", + 43, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, set_item_str_req), + &sr__set_item_str_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "validate_req", + 50, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, validate_req), + &sr__validate_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "commit_req", + 51, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, commit_req), + &sr__commit_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "discard_changes_req", + 52, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, discard_changes_req), + &sr__discard_changes_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "copy_config_req", + 53, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, copy_config_req), + &sr__copy_config_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "lock_req", + 60, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, lock_req), + &sr__lock_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "unlock_req", + 61, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, unlock_req), + &sr__unlock_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscribe_req", + 70, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, subscribe_req), + &sr__subscribe_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "unsubscribe_req", + 71, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, unsubscribe_req), + &sr__unsubscribe_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "check_enabled_running_req", + 72, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, check_enabled_running_req), + &sr__check_enabled_running_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_changes_req", + 73, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, get_changes_req), + &sr__get_changes_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data_provide_req", + 80, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, data_provide_req), + &sr__data_provide_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "check_exec_perm_req", + 81, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, check_exec_perm_req), + &sr__check_exec_perm_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rpc_req", + 82, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, rpc_req), + &sr__rpcreq__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_notif_req", + 83, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, event_notif_req), + &sr__event_notif_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_notif_replay_req", + 84, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Request, event_notif_replay_req), + &sr__event_notif_replay_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__request__field_indices_by_name[] = { + 0, /* field[0] = _id */ + 30, /* field[30] = check_enabled_running_req */ + 33, /* field[33] = check_exec_perm_req */ + 23, /* field[23] = commit_req */ + 25, /* field[25] = copy_config_req */ + 32, /* field[32] = data_provide_req */ + 19, /* field[19] = delete_item_req */ + 24, /* field[24] = discard_changes_req */ + 36, /* field[36] = event_notif_replay_req */ + 35, /* field[35] = event_notif_req */ + 12, /* field[12] = feature_enable_req */ + 31, /* field[31] = get_changes_req */ + 13, /* field[13] = get_item_req */ + 14, /* field[14] = get_items_req */ + 10, /* field[10] = get_schema_req */ + 17, /* field[17] = get_subtree_chunk_req */ + 15, /* field[15] = get_subtree_req */ + 16, /* field[16] = get_subtrees_req */ + 9, /* field[9] = list_schemas_req */ + 26, /* field[26] = lock_req */ + 11, /* field[11] = module_install_req */ + 20, /* field[20] = move_item_req */ + 1, /* field[1] = operation */ + 34, /* field[34] = rpc_req */ + 5, /* field[5] = session_check_req */ + 4, /* field[4] = session_refresh_req */ + 7, /* field[7] = session_set_opts_req */ + 2, /* field[2] = session_start_req */ + 3, /* field[3] = session_stop_req */ + 6, /* field[6] = session_switch_ds_req */ + 18, /* field[18] = set_item_req */ + 21, /* field[21] = set_item_str_req */ + 28, /* field[28] = subscribe_req */ + 27, /* field[27] = unlock_req */ + 29, /* field[29] = unsubscribe_req */ + 22, /* field[22] = validate_req */ + 8, /* field[8] = version_verify_req */ +}; +static const ProtobufCIntRange sr__request__number_ranges[9 + 1] = +{ + { 1, 0 }, + { 10, 2 }, + { 20, 9 }, + { 30, 13 }, + { 40, 18 }, + { 50, 22 }, + { 60, 26 }, + { 70, 28 }, + { 80, 32 }, + { 0, 37 } +}; +const ProtobufCMessageDescriptor sr__request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Request", + "Request", + "Sr__Request", + "sr", + sizeof(Sr__Request), + 37, + sr__request__field_descriptors, + sr__request__field_indices_by_name, + 9, sr__request__number_ranges, + (ProtobufCMessageInit) sr__request__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__response__field_descriptors[38] = +{ + { + "operation", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__Response, operation), + &sr__operation__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "result", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__Response, result), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "error", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, error), + &sr__error__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_start_resp", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, session_start_resp), + &sr__session_start_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_stop_resp", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, session_stop_resp), + &sr__session_stop_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_refresh_resp", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, session_refresh_resp), + &sr__session_refresh_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_check_resp", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, session_check_resp), + &sr__session_check_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_switch_ds_resp", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, session_switch_ds_resp), + &sr__session_switch_ds_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_set_opts_resp", + 15, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, session_set_opts_resp), + &sr__session_set_opts_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "version_verify_resp", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, version_verify_resp), + &sr__version_verify_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "list_schemas_resp", + 20, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, list_schemas_resp), + &sr__list_schemas_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_schema_resp", + 21, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, get_schema_resp), + &sr__get_schema_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_install_resp", + 22, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, module_install_resp), + &sr__module_install_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "feature_enable_resp", + 23, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, feature_enable_resp), + &sr__feature_enable_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_item_resp", + 30, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, get_item_resp), + &sr__get_item_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_items_resp", + 31, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, get_items_resp), + &sr__get_items_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_subtree_resp", + 32, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, get_subtree_resp), + &sr__get_subtree_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_subtrees_resp", + 33, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, get_subtrees_resp), + &sr__get_subtrees_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_subtree_chunk_resp", + 34, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, get_subtree_chunk_resp), + &sr__get_subtree_chunk_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "set_item_resp", + 40, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, set_item_resp), + &sr__set_item_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "delete_item_resp", + 41, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, delete_item_resp), + &sr__delete_item_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "move_item_resp", + 42, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, move_item_resp), + &sr__move_item_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "set_item_str_resp", + 43, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, set_item_str_resp), + &sr__set_item_str_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "validate_resp", + 50, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, validate_resp), + &sr__validate_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "commit_resp", + 51, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, commit_resp), + &sr__commit_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "discard_changes_resp", + 52, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, discard_changes_resp), + &sr__discard_changes_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "copy_config_resp", + 53, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, copy_config_resp), + &sr__copy_config_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "lock_resp", + 60, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, lock_resp), + &sr__lock_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "unlock_resp", + 61, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, unlock_resp), + &sr__unlock_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscribe_resp", + 70, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, subscribe_resp), + &sr__subscribe_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "unsubscribe_resp", + 71, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, unsubscribe_resp), + &sr__unsubscribe_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "check_enabled_running_resp", + 72, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, check_enabled_running_resp), + &sr__check_enabled_running_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "get_changes_resp", + 73, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, get_changes_resp), + &sr__get_changes_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "data_provide_resp", + 80, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, data_provide_resp), + &sr__data_provide_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "check_exec_perm_resp", + 81, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, check_exec_perm_resp), + &sr__check_exec_perm_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rpc_resp", + 82, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, rpc_resp), + &sr__rpcresp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_notif_resp", + 83, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, event_notif_resp), + &sr__event_notif_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "event_notif_replay_resp", + 84, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Response, event_notif_replay_resp), + &sr__event_notif_replay_resp__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__response__field_indices_by_name[] = { + 31, /* field[31] = check_enabled_running_resp */ + 34, /* field[34] = check_exec_perm_resp */ + 24, /* field[24] = commit_resp */ + 26, /* field[26] = copy_config_resp */ + 33, /* field[33] = data_provide_resp */ + 20, /* field[20] = delete_item_resp */ + 25, /* field[25] = discard_changes_resp */ + 2, /* field[2] = error */ + 37, /* field[37] = event_notif_replay_resp */ + 36, /* field[36] = event_notif_resp */ + 13, /* field[13] = feature_enable_resp */ + 32, /* field[32] = get_changes_resp */ + 14, /* field[14] = get_item_resp */ + 15, /* field[15] = get_items_resp */ + 11, /* field[11] = get_schema_resp */ + 18, /* field[18] = get_subtree_chunk_resp */ + 16, /* field[16] = get_subtree_resp */ + 17, /* field[17] = get_subtrees_resp */ + 10, /* field[10] = list_schemas_resp */ + 27, /* field[27] = lock_resp */ + 12, /* field[12] = module_install_resp */ + 21, /* field[21] = move_item_resp */ + 0, /* field[0] = operation */ + 1, /* field[1] = result */ + 35, /* field[35] = rpc_resp */ + 6, /* field[6] = session_check_resp */ + 5, /* field[5] = session_refresh_resp */ + 8, /* field[8] = session_set_opts_resp */ + 3, /* field[3] = session_start_resp */ + 4, /* field[4] = session_stop_resp */ + 7, /* field[7] = session_switch_ds_resp */ + 19, /* field[19] = set_item_resp */ + 22, /* field[22] = set_item_str_resp */ + 29, /* field[29] = subscribe_resp */ + 28, /* field[28] = unlock_resp */ + 30, /* field[30] = unsubscribe_resp */ + 23, /* field[23] = validate_resp */ + 9, /* field[9] = version_verify_resp */ +}; +static const ProtobufCIntRange sr__response__number_ranges[9 + 1] = +{ + { 1, 0 }, + { 10, 3 }, + { 20, 10 }, + { 30, 14 }, + { 40, 19 }, + { 50, 23 }, + { 60, 27 }, + { 70, 29 }, + { 80, 33 }, + { 0, 38 } +}; +const ProtobufCMessageDescriptor sr__response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Response", + "Response", + "Sr__Response", + "sr", + sizeof(Sr__Response), + 38, + sr__response__field_descriptors, + sr__response__field_indices_by_name, + 9, sr__response__number_ranges, + (ProtobufCMessageInit) sr__response__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__notification__field_descriptors[10] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, type), + &sr__subscription_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "destination_address", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, destination_address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "source_address", + 3, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, source_address), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "source_pid", + 4, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, source_pid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subscription_id", + 5, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, subscription_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "commit_id", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__Notification, has_commit_id), + offsetof(Sr__Notification, commit_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_install_notif", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, module_install_notif), + &sr__module_install_notification__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "feature_enable_notif", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, feature_enable_notif), + &sr__feature_enable_notification__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "module_change_notif", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, module_change_notif), + &sr__module_change_notification__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "subtree_change_notif", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Notification, subtree_change_notif), + &sr__subtree_change_notification__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__notification__field_indices_by_name[] = { + 5, /* field[5] = commit_id */ + 1, /* field[1] = destination_address */ + 7, /* field[7] = feature_enable_notif */ + 8, /* field[8] = module_change_notif */ + 6, /* field[6] = module_install_notif */ + 2, /* field[2] = source_address */ + 3, /* field[3] = source_pid */ + 4, /* field[4] = subscription_id */ + 9, /* field[9] = subtree_change_notif */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange sr__notification__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 10, 6 }, + { 0, 10 } +}; +const ProtobufCMessageDescriptor sr__notification__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Notification", + "Notification", + "Sr__Notification", + "sr", + sizeof(Sr__Notification), + 10, + sr__notification__field_descriptors, + sr__notification__field_indices_by_name, + 2, sr__notification__number_ranges, + (ProtobufCMessageInit) sr__notification__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__notification_ack__field_descriptors[4] = +{ + { + "notif", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__NotificationAck, notif), + &sr__notification__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "result", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__NotificationAck, result), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "error", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__NotificationAck, error), + &sr__error__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "do_not_send_abort", + 4, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_BOOL, + 0, /* quantifier_offset */ + offsetof(Sr__NotificationAck, do_not_send_abort), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__notification_ack__field_indices_by_name[] = { + 3, /* field[3] = do_not_send_abort */ + 2, /* field[2] = error */ + 0, /* field[0] = notif */ + 1, /* field[1] = result */ +}; +static const ProtobufCIntRange sr__notification_ack__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor sr__notification_ack__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.NotificationAck", + "NotificationAck", + "Sr__NotificationAck", + "sr", + sizeof(Sr__NotificationAck), + 4, + sr__notification_ack__field_descriptors, + sr__notification_ack__field_indices_by_name, + 1, sr__notification_ack__number_ranges, + (ProtobufCMessageInit) sr__notification_ack__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sr__internal_request__field_descriptors[9] = +{ + { + "operation", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__InternalRequest, operation), + &sr__operation__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "postpone_timeout", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sr__InternalRequest, has_postpone_timeout), + offsetof(Sr__InternalRequest, postpone_timeout), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "unsubscribe_dst_req", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__InternalRequest, unsubscribe_dst_req), + &sr__unsubscribe_destination_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "commit_timeout_req", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__InternalRequest, commit_timeout_req), + &sr__commit_timeout_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "oper_data_timeout_req", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__InternalRequest, oper_data_timeout_req), + &sr__oper_data_timeout_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "internal_state_data_req", + 13, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__InternalRequest, internal_state_data_req), + &sr__internal_state_data_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "notif_store_cleanup_req", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__InternalRequest, notif_store_cleanup_req), + &sr__notif_store_cleanup_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "delayed_msg_req", + 15, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__InternalRequest, delayed_msg_req), + &sr__delayed_msg_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "nacm_reload_req", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__InternalRequest, nacm_reload_req), + &sr__nacm_reload_req__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__internal_request__field_indices_by_name[] = { + 3, /* field[3] = commit_timeout_req */ + 7, /* field[7] = delayed_msg_req */ + 5, /* field[5] = internal_state_data_req */ + 8, /* field[8] = nacm_reload_req */ + 6, /* field[6] = notif_store_cleanup_req */ + 4, /* field[4] = oper_data_timeout_req */ + 0, /* field[0] = operation */ + 1, /* field[1] = postpone_timeout */ + 2, /* field[2] = unsubscribe_dst_req */ +}; +static const ProtobufCIntRange sr__internal_request__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 10, 2 }, + { 0, 9 } +}; +const ProtobufCMessageDescriptor sr__internal_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.InternalRequest", + "InternalRequest", + "Sr__InternalRequest", + "sr", + sizeof(Sr__InternalRequest), + 9, + sr__internal_request__field_descriptors, + sr__internal_request__field_indices_by_name, + 2, sr__internal_request__number_ranges, + (ProtobufCMessageInit) sr__internal_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCEnumValue sr__msg__msg_type__enum_values_by_number[5] = +{ + { "REQUEST", "SR__MSG__MSG_TYPE__REQUEST", 1 }, + { "RESPONSE", "SR__MSG__MSG_TYPE__RESPONSE", 2 }, + { "NOTIFICATION", "SR__MSG__MSG_TYPE__NOTIFICATION", 3 }, + { "NOTIFICATION_ACK", "SR__MSG__MSG_TYPE__NOTIFICATION_ACK", 4 }, + { "INTERNAL_REQUEST", "SR__MSG__MSG_TYPE__INTERNAL_REQUEST", 5 }, +}; +static const ProtobufCIntRange sr__msg__msg_type__value_ranges[] = { +{1, 0},{0, 5} +}; +static const ProtobufCEnumValueIndex sr__msg__msg_type__enum_values_by_name[5] = +{ + { "INTERNAL_REQUEST", 4 }, + { "NOTIFICATION", 2 }, + { "NOTIFICATION_ACK", 3 }, + { "REQUEST", 0 }, + { "RESPONSE", 1 }, +}; +const ProtobufCEnumDescriptor sr__msg__msg_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.Msg.MsgType", + "MsgType", + "Sr__Msg__MsgType", + "sr", + 5, + sr__msg__msg_type__enum_values_by_number, + 5, + sr__msg__msg_type__enum_values_by_name, + 1, + sr__msg__msg_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCFieldDescriptor sr__msg__field_descriptors[8] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sr__Msg, type), + &sr__msg__msg_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_id", + 2, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT32, + 0, /* quantifier_offset */ + offsetof(Sr__Msg, session_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "request", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Msg, request), + &sr__request__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "response", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Msg, response), + &sr__response__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "notification", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Msg, notification), + &sr__notification__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "notification_ack", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Msg, notification_ack), + &sr__notification_ack__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "internal_request", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sr__Msg, internal_request), + &sr__internal_request__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "_sysrepo_mem_ctx", + 20, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_UINT64, + 0, /* quantifier_offset */ + offsetof(Sr__Msg, _sysrepo_mem_ctx), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sr__msg__field_indices_by_name[] = { + 7, /* field[7] = _sysrepo_mem_ctx */ + 6, /* field[6] = internal_request */ + 4, /* field[4] = notification */ + 5, /* field[5] = notification_ack */ + 2, /* field[2] = request */ + 3, /* field[3] = response */ + 1, /* field[1] = session_id */ + 0, /* field[0] = type */ +}; +static const ProtobufCIntRange sr__msg__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 20, 7 }, + { 0, 8 } +}; +const ProtobufCMessageDescriptor sr__msg__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sr.Msg", + "Msg", + "Sr__Msg", + "sr", + sizeof(Sr__Msg), + 8, + sr__msg__field_descriptors, + sr__msg__field_indices_by_name, + 2, sr__msg__number_ranges, + (ProtobufCMessageInit) sr__msg__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCEnumValue sr__api_variant__enum_values_by_number[2] = +{ + { "VALUES", "SR__API_VARIANT__VALUES", 1 }, + { "TREES", "SR__API_VARIANT__TREES", 2 }, +}; +static const ProtobufCIntRange sr__api_variant__value_ranges[] = { +{1, 0},{0, 2} +}; +static const ProtobufCEnumValueIndex sr__api_variant__enum_values_by_name[2] = +{ + { "TREES", 1 }, + { "VALUES", 0 }, +}; +const ProtobufCEnumDescriptor sr__api_variant__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.ApiVariant", + "ApiVariant", + "Sr__ApiVariant", + "sr", + 2, + sr__api_variant__enum_values_by_number, + 2, + sr__api_variant__enum_values_by_name, + 1, + sr__api_variant__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__data_store__enum_values_by_number[3] = +{ + { "STARTUP", "SR__DATA_STORE__STARTUP", 1 }, + { "RUNNING", "SR__DATA_STORE__RUNNING", 2 }, + { "CANDIDATE", "SR__DATA_STORE__CANDIDATE", 3 }, +}; +static const ProtobufCIntRange sr__data_store__value_ranges[] = { +{1, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex sr__data_store__enum_values_by_name[3] = +{ + { "CANDIDATE", 2 }, + { "RUNNING", 1 }, + { "STARTUP", 0 }, +}; +const ProtobufCEnumDescriptor sr__data_store__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.DataStore", + "DataStore", + "Sr__DataStore", + "sr", + 3, + sr__data_store__enum_values_by_number, + 3, + sr__data_store__enum_values_by_name, + 1, + sr__data_store__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__session_flags__enum_values_by_number[4] = +{ + { "SESS_DEFAULT", "SR__SESSION_FLAGS__SESS_DEFAULT", 0 }, + { "SESS_CONFIG_ONLY", "SR__SESSION_FLAGS__SESS_CONFIG_ONLY", 1 }, + { "SESS_ENABLE_NACM", "SR__SESSION_FLAGS__SESS_ENABLE_NACM", 2 }, + { "SESS_NOTIFICATION", "SR__SESSION_FLAGS__SESS_NOTIFICATION", 1024 }, +}; +static const ProtobufCIntRange sr__session_flags__value_ranges[] = { +{0, 0},{1024, 3},{0, 4} +}; +static const ProtobufCEnumValueIndex sr__session_flags__enum_values_by_name[4] = +{ + { "SESS_CONFIG_ONLY", 1 }, + { "SESS_DEFAULT", 0 }, + { "SESS_ENABLE_NACM", 2 }, + { "SESS_NOTIFICATION", 3 }, +}; +const ProtobufCEnumDescriptor sr__session_flags__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.SessionFlags", + "SessionFlags", + "Sr__SessionFlags", + "sr", + 4, + sr__session_flags__enum_values_by_number, + 4, + sr__session_flags__enum_values_by_name, + 2, + sr__session_flags__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__edit_flags__enum_values_by_number[3] = +{ + { "EDIT_DEFAULT", "SR__EDIT_FLAGS__EDIT_DEFAULT", 0 }, + { "EDIT_NON_RECURSIVE", "SR__EDIT_FLAGS__EDIT_NON_RECURSIVE", 1 }, + { "EDIT_STRICT", "SR__EDIT_FLAGS__EDIT_STRICT", 2 }, +}; +static const ProtobufCIntRange sr__edit_flags__value_ranges[] = { +{0, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex sr__edit_flags__enum_values_by_name[3] = +{ + { "EDIT_DEFAULT", 0 }, + { "EDIT_NON_RECURSIVE", 1 }, + { "EDIT_STRICT", 2 }, +}; +const ProtobufCEnumDescriptor sr__edit_flags__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.EditFlags", + "EditFlags", + "Sr__EditFlags", + "sr", + 3, + sr__edit_flags__enum_values_by_number, + 3, + sr__edit_flags__enum_values_by_name, + 1, + sr__edit_flags__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__subscription_type__enum_values_by_number[10] = +{ + { "MODULE_INSTALL_SUBS", "SR__SUBSCRIPTION_TYPE__MODULE_INSTALL_SUBS", 1 }, + { "FEATURE_ENABLE_SUBS", "SR__SUBSCRIPTION_TYPE__FEATURE_ENABLE_SUBS", 2 }, + { "MODULE_CHANGE_SUBS", "SR__SUBSCRIPTION_TYPE__MODULE_CHANGE_SUBS", 10 }, + { "SUBTREE_CHANGE_SUBS", "SR__SUBSCRIPTION_TYPE__SUBTREE_CHANGE_SUBS", 11 }, + { "DP_GET_ITEMS_SUBS", "SR__SUBSCRIPTION_TYPE__DP_GET_ITEMS_SUBS", 20 }, + { "RPC_SUBS", "SR__SUBSCRIPTION_TYPE__RPC_SUBS", 30 }, + { "ACTION_SUBS", "SR__SUBSCRIPTION_TYPE__ACTION_SUBS", 31 }, + { "EVENT_NOTIF_SUBS", "SR__SUBSCRIPTION_TYPE__EVENT_NOTIF_SUBS", 40 }, + { "HELLO_SUBS", "SR__SUBSCRIPTION_TYPE__HELLO_SUBS", 50 }, + { "COMMIT_END_SUBS", "SR__SUBSCRIPTION_TYPE__COMMIT_END_SUBS", 51 }, +}; +static const ProtobufCIntRange sr__subscription_type__value_ranges[] = { +{1, 0},{10, 2},{20, 4},{30, 5},{40, 7},{50, 8},{0, 10} +}; +static const ProtobufCEnumValueIndex sr__subscription_type__enum_values_by_name[10] = +{ + { "ACTION_SUBS", 6 }, + { "COMMIT_END_SUBS", 9 }, + { "DP_GET_ITEMS_SUBS", 4 }, + { "EVENT_NOTIF_SUBS", 7 }, + { "FEATURE_ENABLE_SUBS", 1 }, + { "HELLO_SUBS", 8 }, + { "MODULE_CHANGE_SUBS", 2 }, + { "MODULE_INSTALL_SUBS", 0 }, + { "RPC_SUBS", 5 }, + { "SUBTREE_CHANGE_SUBS", 3 }, +}; +const ProtobufCEnumDescriptor sr__subscription_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.SubscriptionType", + "SubscriptionType", + "Sr__SubscriptionType", + "sr", + 10, + sr__subscription_type__enum_values_by_number, + 10, + sr__subscription_type__enum_values_by_name, + 6, + sr__subscription_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__notification_event__enum_values_by_number[4] = +{ + { "VERIFY_EV", "SR__NOTIFICATION_EVENT__VERIFY_EV", 1 }, + { "APPLY_EV", "SR__NOTIFICATION_EVENT__APPLY_EV", 2 }, + { "ABORT_EV", "SR__NOTIFICATION_EVENT__ABORT_EV", 3 }, + { "ENABLED_EV", "SR__NOTIFICATION_EVENT__ENABLED_EV", 4 }, +}; +static const ProtobufCIntRange sr__notification_event__value_ranges[] = { +{1, 0},{0, 4} +}; +static const ProtobufCEnumValueIndex sr__notification_event__enum_values_by_name[4] = +{ + { "ABORT_EV", 2 }, + { "APPLY_EV", 1 }, + { "ENABLED_EV", 3 }, + { "VERIFY_EV", 0 }, +}; +const ProtobufCEnumDescriptor sr__notification_event__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.NotificationEvent", + "NotificationEvent", + "Sr__NotificationEvent", + "sr", + 4, + sr__notification_event__enum_values_by_number, + 4, + sr__notification_event__enum_values_by_name, + 1, + sr__notification_event__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__module_state__enum_values_by_number[3] = +{ + { "UNINSTALLED", "SR__MODULE_STATE__UNINSTALLED", 1 }, + { "IMPORTED", "SR__MODULE_STATE__IMPORTED", 2 }, + { "IMPLEMENTED", "SR__MODULE_STATE__IMPLEMENTED", 3 }, +}; +static const ProtobufCIntRange sr__module_state__value_ranges[] = { +{1, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex sr__module_state__enum_values_by_name[3] = +{ + { "IMPLEMENTED", 2 }, + { "IMPORTED", 1 }, + { "UNINSTALLED", 0 }, +}; +const ProtobufCEnumDescriptor sr__module_state__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.ModuleState", + "ModuleState", + "Sr__ModuleState", + "sr", + 3, + sr__module_state__enum_values_by_number, + 3, + sr__module_state__enum_values_by_name, + 1, + sr__module_state__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__change_operation__enum_values_by_number[4] = +{ + { "CREATED", "SR__CHANGE_OPERATION__CREATED", 1 }, + { "MODIFIED", "SR__CHANGE_OPERATION__MODIFIED", 2 }, + { "DELETED", "SR__CHANGE_OPERATION__DELETED", 3 }, + { "MOVED", "SR__CHANGE_OPERATION__MOVED", 4 }, +}; +static const ProtobufCIntRange sr__change_operation__value_ranges[] = { +{1, 0},{0, 4} +}; +static const ProtobufCEnumValueIndex sr__change_operation__enum_values_by_name[4] = +{ + { "CREATED", 0 }, + { "DELETED", 2 }, + { "MODIFIED", 1 }, + { "MOVED", 3 }, +}; +const ProtobufCEnumDescriptor sr__change_operation__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.ChangeOperation", + "ChangeOperation", + "Sr__ChangeOperation", + "sr", + 4, + sr__change_operation__enum_values_by_number, + 4, + sr__change_operation__enum_values_by_name, + 1, + sr__change_operation__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; +static const ProtobufCEnumValue sr__operation__enum_values_by_number[43] = +{ + { "SESSION_START", "SR__OPERATION__SESSION_START", 10 }, + { "SESSION_STOP", "SR__OPERATION__SESSION_STOP", 11 }, + { "SESSION_REFRESH", "SR__OPERATION__SESSION_REFRESH", 12 }, + { "SESSION_CHECK", "SR__OPERATION__SESSION_CHECK", 13 }, + { "SESSION_SWITCH_DS", "SR__OPERATION__SESSION_SWITCH_DS", 14 }, + { "SESSION_SET_OPTS", "SR__OPERATION__SESSION_SET_OPTS", 15 }, + { "VERSION_VERIFY", "SR__OPERATION__VERSION_VERIFY", 16 }, + { "LIST_SCHEMAS", "SR__OPERATION__LIST_SCHEMAS", 20 }, + { "GET_SCHEMA", "SR__OPERATION__GET_SCHEMA", 21 }, + { "MODULE_INSTALL", "SR__OPERATION__MODULE_INSTALL", 22 }, + { "FEATURE_ENABLE", "SR__OPERATION__FEATURE_ENABLE", 23 }, + { "GET_ITEM", "SR__OPERATION__GET_ITEM", 30 }, + { "GET_ITEMS", "SR__OPERATION__GET_ITEMS", 31 }, + { "GET_SUBTREE", "SR__OPERATION__GET_SUBTREE", 32 }, + { "GET_SUBTREES", "SR__OPERATION__GET_SUBTREES", 33 }, + { "GET_SUBTREE_CHUNK", "SR__OPERATION__GET_SUBTREE_CHUNK", 34 }, + { "SET_ITEM", "SR__OPERATION__SET_ITEM", 40 }, + { "DELETE_ITEM", "SR__OPERATION__DELETE_ITEM", 41 }, + { "MOVE_ITEM", "SR__OPERATION__MOVE_ITEM", 42 }, + { "SET_ITEM_STR", "SR__OPERATION__SET_ITEM_STR", 43 }, + { "VALIDATE", "SR__OPERATION__VALIDATE", 50 }, + { "COMMIT", "SR__OPERATION__COMMIT", 51 }, + { "DISCARD_CHANGES", "SR__OPERATION__DISCARD_CHANGES", 52 }, + { "COPY_CONFIG", "SR__OPERATION__COPY_CONFIG", 53 }, + { "LOCK", "SR__OPERATION__LOCK", 60 }, + { "UNLOCK", "SR__OPERATION__UNLOCK", 61 }, + { "SUBSCRIBE", "SR__OPERATION__SUBSCRIBE", 70 }, + { "UNSUBSCRIBE", "SR__OPERATION__UNSUBSCRIBE", 71 }, + { "CHECK_ENABLED_RUNNING", "SR__OPERATION__CHECK_ENABLED_RUNNING", 72 }, + { "GET_CHANGES", "SR__OPERATION__GET_CHANGES", 73 }, + { "DATA_PROVIDE", "SR__OPERATION__DATA_PROVIDE", 80 }, + { "CHECK_EXEC_PERMISSION", "SR__OPERATION__CHECK_EXEC_PERMISSION", 81 }, + { "RPC", "SR__OPERATION__RPC", 82 }, + { "ACTION", "SR__OPERATION__ACTION", 83 }, + { "EVENT_NOTIF", "SR__OPERATION__EVENT_NOTIF", 84 }, + { "EVENT_NOTIF_REPLAY", "SR__OPERATION__EVENT_NOTIF_REPLAY", 85 }, + { "UNSUBSCRIBE_DESTINATION", "SR__OPERATION__UNSUBSCRIBE_DESTINATION", 101 }, + { "COMMIT_TIMEOUT", "SR__OPERATION__COMMIT_TIMEOUT", 102 }, + { "OPER_DATA_TIMEOUT", "SR__OPERATION__OPER_DATA_TIMEOUT", 103 }, + { "INTERNAL_STATE_DATA", "SR__OPERATION__INTERNAL_STATE_DATA", 104 }, + { "NOTIF_STORE_CLEANUP", "SR__OPERATION__NOTIF_STORE_CLEANUP", 105 }, + { "DELAYED_MSG", "SR__OPERATION__DELAYED_MSG", 106 }, + { "NACM_RELOAD", "SR__OPERATION__NACM_RELOAD", 107 }, +}; +static const ProtobufCIntRange sr__operation__value_ranges[] = { +{10, 0},{20, 7},{30, 11},{40, 16},{50, 20},{60, 24},{70, 26},{80, 30},{101, 36},{0, 43} +}; +static const ProtobufCEnumValueIndex sr__operation__enum_values_by_name[43] = +{ + { "ACTION", 33 }, + { "CHECK_ENABLED_RUNNING", 28 }, + { "CHECK_EXEC_PERMISSION", 31 }, + { "COMMIT", 21 }, + { "COMMIT_TIMEOUT", 37 }, + { "COPY_CONFIG", 23 }, + { "DATA_PROVIDE", 30 }, + { "DELAYED_MSG", 41 }, + { "DELETE_ITEM", 17 }, + { "DISCARD_CHANGES", 22 }, + { "EVENT_NOTIF", 34 }, + { "EVENT_NOTIF_REPLAY", 35 }, + { "FEATURE_ENABLE", 10 }, + { "GET_CHANGES", 29 }, + { "GET_ITEM", 11 }, + { "GET_ITEMS", 12 }, + { "GET_SCHEMA", 8 }, + { "GET_SUBTREE", 13 }, + { "GET_SUBTREES", 14 }, + { "GET_SUBTREE_CHUNK", 15 }, + { "INTERNAL_STATE_DATA", 39 }, + { "LIST_SCHEMAS", 7 }, + { "LOCK", 24 }, + { "MODULE_INSTALL", 9 }, + { "MOVE_ITEM", 18 }, + { "NACM_RELOAD", 42 }, + { "NOTIF_STORE_CLEANUP", 40 }, + { "OPER_DATA_TIMEOUT", 38 }, + { "RPC", 32 }, + { "SESSION_CHECK", 3 }, + { "SESSION_REFRESH", 2 }, + { "SESSION_SET_OPTS", 5 }, + { "SESSION_START", 0 }, + { "SESSION_STOP", 1 }, + { "SESSION_SWITCH_DS", 4 }, + { "SET_ITEM", 16 }, + { "SET_ITEM_STR", 19 }, + { "SUBSCRIBE", 26 }, + { "UNLOCK", 25 }, + { "UNSUBSCRIBE", 27 }, + { "UNSUBSCRIBE_DESTINATION", 36 }, + { "VALIDATE", 20 }, + { "VERSION_VERIFY", 6 }, +}; +const ProtobufCEnumDescriptor sr__operation__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sr.Operation", + "Operation", + "Sr__Operation", + "sr", + 43, + sr__operation__enum_values_by_number, + 43, + sr__operation__enum_values_by_name, + 9, + sr__operation__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; Index: sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/common/sysrepo.pb-c.h =================================================================== --- /dev/null +++ sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/common/sysrepo.pb-c.h @@ -0,0 +1,4238 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: sysrepo.proto */ + +#ifndef PROTOBUF_C_sysrepo_2eproto__INCLUDED +#define PROTOBUF_C_sysrepo_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1000000 +# 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 1002001 < 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 _Sr__Value Sr__Value; +typedef struct _Sr__Node Sr__Node; +typedef struct _Sr__Error Sr__Error; +typedef struct _Sr__SessionStartReq Sr__SessionStartReq; +typedef struct _Sr__SessionStartResp Sr__SessionStartResp; +typedef struct _Sr__SessionStopReq Sr__SessionStopReq; +typedef struct _Sr__SessionStopResp Sr__SessionStopResp; +typedef struct _Sr__SessionRefreshReq Sr__SessionRefreshReq; +typedef struct _Sr__SessionRefreshResp Sr__SessionRefreshResp; +typedef struct _Sr__SessionCheckReq Sr__SessionCheckReq; +typedef struct _Sr__SessionCheckResp Sr__SessionCheckResp; +typedef struct _Sr__SessionSwitchDsReq Sr__SessionSwitchDsReq; +typedef struct _Sr__SessionSwitchDsResp Sr__SessionSwitchDsResp; +typedef struct _Sr__SessionSetOptsReq Sr__SessionSetOptsReq; +typedef struct _Sr__SessionSetOptsResp Sr__SessionSetOptsResp; +typedef struct _Sr__VersionVerifyReq Sr__VersionVerifyReq; +typedef struct _Sr__VersionVerifyResp Sr__VersionVerifyResp; +typedef struct _Sr__SchemaRevision Sr__SchemaRevision; +typedef struct _Sr__SchemaSubmodule Sr__SchemaSubmodule; +typedef struct _Sr__Schema Sr__Schema; +typedef struct _Sr__ListSchemasReq Sr__ListSchemasReq; +typedef struct _Sr__ListSchemasResp Sr__ListSchemasResp; +typedef struct _Sr__GetSchemaReq Sr__GetSchemaReq; +typedef struct _Sr__GetSchemaResp Sr__GetSchemaResp; +typedef struct _Sr__GetItemReq Sr__GetItemReq; +typedef struct _Sr__GetItemResp Sr__GetItemResp; +typedef struct _Sr__GetItemsReq Sr__GetItemsReq; +typedef struct _Sr__GetItemsResp Sr__GetItemsResp; +typedef struct _Sr__GetSubtreeReq Sr__GetSubtreeReq; +typedef struct _Sr__GetSubtreeResp Sr__GetSubtreeResp; +typedef struct _Sr__GetSubtreesReq Sr__GetSubtreesReq; +typedef struct _Sr__GetSubtreesResp Sr__GetSubtreesResp; +typedef struct _Sr__GetSubtreeChunkReq Sr__GetSubtreeChunkReq; +typedef struct _Sr__GetSubtreeChunkResp Sr__GetSubtreeChunkResp; +typedef struct _Sr__SetItemReq Sr__SetItemReq; +typedef struct _Sr__SetItemResp Sr__SetItemResp; +typedef struct _Sr__SetItemStrReq Sr__SetItemStrReq; +typedef struct _Sr__SetItemStrResp Sr__SetItemStrResp; +typedef struct _Sr__DeleteItemReq Sr__DeleteItemReq; +typedef struct _Sr__DeleteItemResp Sr__DeleteItemResp; +typedef struct _Sr__MoveItemReq Sr__MoveItemReq; +typedef struct _Sr__MoveItemResp Sr__MoveItemResp; +typedef struct _Sr__ValidateReq Sr__ValidateReq; +typedef struct _Sr__ValidateResp Sr__ValidateResp; +typedef struct _Sr__CommitReq Sr__CommitReq; +typedef struct _Sr__CommitResp Sr__CommitResp; +typedef struct _Sr__DiscardChangesReq Sr__DiscardChangesReq; +typedef struct _Sr__DiscardChangesResp Sr__DiscardChangesResp; +typedef struct _Sr__CopyConfigReq Sr__CopyConfigReq; +typedef struct _Sr__CopyConfigResp Sr__CopyConfigResp; +typedef struct _Sr__LockReq Sr__LockReq; +typedef struct _Sr__LockResp Sr__LockResp; +typedef struct _Sr__UnlockReq Sr__UnlockReq; +typedef struct _Sr__UnlockResp Sr__UnlockResp; +typedef struct _Sr__SubscribeReq Sr__SubscribeReq; +typedef struct _Sr__SubscribeResp Sr__SubscribeResp; +typedef struct _Sr__UnsubscribeReq Sr__UnsubscribeReq; +typedef struct _Sr__UnsubscribeResp Sr__UnsubscribeResp; +typedef struct _Sr__CheckEnabledRunningReq Sr__CheckEnabledRunningReq; +typedef struct _Sr__CheckEnabledRunningResp Sr__CheckEnabledRunningResp; +typedef struct _Sr__ModuleInstallNotification Sr__ModuleInstallNotification; +typedef struct _Sr__FeatureEnableNotification Sr__FeatureEnableNotification; +typedef struct _Sr__ModuleChangeNotification Sr__ModuleChangeNotification; +typedef struct _Sr__SubtreeChangeNotification Sr__SubtreeChangeNotification; +typedef struct _Sr__Change Sr__Change; +typedef struct _Sr__GetChangesReq Sr__GetChangesReq; +typedef struct _Sr__GetChangesResp Sr__GetChangesResp; +typedef struct _Sr__CheckExecPermReq Sr__CheckExecPermReq; +typedef struct _Sr__CheckExecPermResp Sr__CheckExecPermResp; +typedef struct _Sr__RPCReq Sr__RPCReq; +typedef struct _Sr__RPCResp Sr__RPCResp; +typedef struct _Sr__EventNotifReq Sr__EventNotifReq; +typedef struct _Sr__EventNotifResp Sr__EventNotifResp; +typedef struct _Sr__EventNotifReplayReq Sr__EventNotifReplayReq; +typedef struct _Sr__EventNotifReplayResp Sr__EventNotifReplayResp; +typedef struct _Sr__DataProvideReq Sr__DataProvideReq; +typedef struct _Sr__DataProvideResp Sr__DataProvideResp; +typedef struct _Sr__ModuleInstallReq Sr__ModuleInstallReq; +typedef struct _Sr__ModuleInstallResp Sr__ModuleInstallResp; +typedef struct _Sr__FeatureEnableReq Sr__FeatureEnableReq; +typedef struct _Sr__FeatureEnableResp Sr__FeatureEnableResp; +typedef struct _Sr__UnsubscribeDestinationReq Sr__UnsubscribeDestinationReq; +typedef struct _Sr__CommitTimeoutReq Sr__CommitTimeoutReq; +typedef struct _Sr__OperDataTimeoutReq Sr__OperDataTimeoutReq; +typedef struct _Sr__InternalStateDataReq Sr__InternalStateDataReq; +typedef struct _Sr__NotifStoreCleanupReq Sr__NotifStoreCleanupReq; +typedef struct _Sr__DelayedMsgReq Sr__DelayedMsgReq; +typedef struct _Sr__NacmReloadReq Sr__NacmReloadReq; +typedef struct _Sr__Request Sr__Request; +typedef struct _Sr__Response Sr__Response; +typedef struct _Sr__Notification Sr__Notification; +typedef struct _Sr__NotificationAck Sr__NotificationAck; +typedef struct _Sr__InternalRequest Sr__InternalRequest; +typedef struct _Sr__Msg Sr__Msg; + + +/* --- enums --- */ + +typedef enum _Sr__Value__Types { + SR__VALUE__TYPES__LIST = 1, + SR__VALUE__TYPES__CONTAINER = 2, + SR__VALUE__TYPES__CONTAINER_PRESENCE = 3, + SR__VALUE__TYPES__LEAF_EMPTY = 4, + SR__VALUE__TYPES__BINARY = 10, + SR__VALUE__TYPES__BITS = 11, + SR__VALUE__TYPES__BOOL = 12, + SR__VALUE__TYPES__DECIMAL64 = 13, + SR__VALUE__TYPES__ENUM = 14, + SR__VALUE__TYPES__IDENTITYREF = 15, + SR__VALUE__TYPES__INSTANCEID = 16, + SR__VALUE__TYPES__INT8 = 17, + SR__VALUE__TYPES__INT16 = 18, + SR__VALUE__TYPES__INT32 = 19, + SR__VALUE__TYPES__INT64 = 20, + SR__VALUE__TYPES__STRING = 21, + SR__VALUE__TYPES__UINT8 = 22, + SR__VALUE__TYPES__UINT16 = 23, + SR__VALUE__TYPES__UINT32 = 24, + SR__VALUE__TYPES__UINT64 = 25, + SR__VALUE__TYPES__ANYXML = 26, + SR__VALUE__TYPES__ANYDATA = 27 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__VALUE__TYPES) +} Sr__Value__Types; +typedef enum _Sr__MoveItemReq__MovePosition { + SR__MOVE_ITEM_REQ__MOVE_POSITION__BEFORE = 1, + SR__MOVE_ITEM_REQ__MOVE_POSITION__AFTER = 2, + SR__MOVE_ITEM_REQ__MOVE_POSITION__FIRST = 3, + SR__MOVE_ITEM_REQ__MOVE_POSITION__LAST = 4 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MOVE_ITEM_REQ__MOVE_POSITION) +} Sr__MoveItemReq__MovePosition; +/* + ** + * @brief Type of the event notification. + */ +typedef enum _Sr__EventNotifReq__NotifType { + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REALTIME = 1, + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY = 2, + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_COMPLETE = 3, + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_STOP = 4 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EVENT_NOTIF_REQ__NOTIF_TYPE) +} Sr__EventNotifReq__NotifType; +/* + ** + * @brief Flags used to override default session handling. + */ +typedef enum _Sr__EventNotifReq__NotifFlags { + /* + **< Notification will be handled normally. + */ + SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__DEFAULT = 0, + /* + **< Notification will not be stored in the notification store. + */ + SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__EPHEMERAL = 1 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EVENT_NOTIF_REQ__NOTIF_FLAGS) +} Sr__EventNotifReq__NotifFlags; +/* + ** + * @brief Type of the message. + */ +typedef enum _Sr__Msg__MsgType { + /* + **< The message is a request. + */ + SR__MSG__MSG_TYPE__REQUEST = 1, + /* + **< The message is a response to the request. + */ + SR__MSG__MSG_TYPE__RESPONSE = 2, + /* + **< The message is a notification. + */ + SR__MSG__MSG_TYPE__NOTIFICATION = 3, + /* + **< The message is a notification acknowledgment. + */ + SR__MSG__MSG_TYPE__NOTIFICATION_ACK = 4, + /* + **< The message is an internal request, should not be used from the public API. + */ + SR__MSG__MSG_TYPE__INTERNAL_REQUEST = 5 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MSG__MSG_TYPE) +} Sr__Msg__MsgType; +/* + ** + * @brief Variant of the API. Currently only values (sr_val_t) vs. trees (sr_node_t). + */ +typedef enum _Sr__ApiVariant { + SR__API_VARIANT__VALUES = 1, + SR__API_VARIANT__TREES = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__API_VARIANT) +} Sr__ApiVariant; +/* + ** + * @brief Datastore on which the configuration session will operate. + */ +typedef enum _Sr__DataStore { + SR__DATA_STORE__STARTUP = 1, + SR__DATA_STORE__RUNNING = 2, + SR__DATA_STORE__CANDIDATE = 3 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__DATA_STORE) +} Sr__DataStore; +/* + ** + * @brief Flags used to override default session handling. + */ +typedef enum _Sr__SessionFlags { + /* + **< Default (normal) session behavior. + */ + SR__SESSION_FLAGS__SESS_DEFAULT = 0, + /* + **< Session will process only configuration data (e.g. sysrepo won't + *return any state data by ::sr_get_items / ::sr_get_items_iter calls). + */ + SR__SESSION_FLAGS__SESS_CONFIG_ONLY = 1, + /* + **< Enable NETCONF access control for this session. + */ + SR__SESSION_FLAGS__SESS_ENABLE_NACM = 2, + /* + **< Notification session (internal type of session). + */ + SR__SESSION_FLAGS__SESS_NOTIFICATION = 1024 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__SESSION_FLAGS) +} Sr__SessionFlags; +/* + ** + * @brief Flags used to override default behavior of data manipulation calls. + */ +typedef enum _Sr__EditFlags { + /* + **< Default behavior - recursive and non-strict. + */ + SR__EDIT_FLAGS__EDIT_DEFAULT = 0, + /* + **< Non-recursive behavior: + *by ::SetItemReq, all preceding nodes (parents) of the identified element must exist, + *by ::DeleteItemReq xpath must not identify an non-empty list or non-empty container. + */ + SR__EDIT_FLAGS__EDIT_NON_RECURSIVE = 1, + /* + **< Strict behavior: + *by ::SetItemReq the identified element must not exist (similar to netconf create operation), + *by ::DeleteItemReq the identified element must exist (similar to netconf delete operation). + */ + SR__EDIT_FLAGS__EDIT_STRICT = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EDIT_FLAGS) +} Sr__EditFlags; +typedef enum _Sr__SubscriptionType { + SR__SUBSCRIPTION_TYPE__MODULE_INSTALL_SUBS = 1, + SR__SUBSCRIPTION_TYPE__FEATURE_ENABLE_SUBS = 2, + SR__SUBSCRIPTION_TYPE__MODULE_CHANGE_SUBS = 10, + SR__SUBSCRIPTION_TYPE__SUBTREE_CHANGE_SUBS = 11, + SR__SUBSCRIPTION_TYPE__DP_GET_ITEMS_SUBS = 20, + SR__SUBSCRIPTION_TYPE__RPC_SUBS = 30, + SR__SUBSCRIPTION_TYPE__ACTION_SUBS = 31, + SR__SUBSCRIPTION_TYPE__EVENT_NOTIF_SUBS = 40, + /* + **< Used only internally to test for inactive notification subscriptions. + */ + SR__SUBSCRIPTION_TYPE__HELLO_SUBS = 50, + /* + **< Used only internally to notify about the end of the commit process. + */ + SR__SUBSCRIPTION_TYPE__COMMIT_END_SUBS = 51 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__SUBSCRIPTION_TYPE) +} Sr__SubscriptionType; +typedef enum _Sr__NotificationEvent { + SR__NOTIFICATION_EVENT__VERIFY_EV = 1, + SR__NOTIFICATION_EVENT__APPLY_EV = 2, + SR__NOTIFICATION_EVENT__ABORT_EV = 3, + SR__NOTIFICATION_EVENT__ENABLED_EV = 4 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__NOTIFICATION_EVENT) +} Sr__NotificationEvent; +typedef enum _Sr__ModuleState { + SR__MODULE_STATE__UNINSTALLED = 1, + SR__MODULE_STATE__IMPORTED = 2, + SR__MODULE_STATE__IMPLEMENTED = 3 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MODULE_STATE) +} Sr__ModuleState; +typedef enum _Sr__ChangeOperation { + SR__CHANGE_OPERATION__CREATED = 1, + SR__CHANGE_OPERATION__MODIFIED = 2, + SR__CHANGE_OPERATION__DELETED = 3, + SR__CHANGE_OPERATION__MOVED = 4 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__CHANGE_OPERATION) +} Sr__ChangeOperation; +/* + ** + * @brief Requested operation. + */ +typedef enum _Sr__Operation { + SR__OPERATION__SESSION_START = 10, + SR__OPERATION__SESSION_STOP = 11, + SR__OPERATION__SESSION_REFRESH = 12, + SR__OPERATION__SESSION_CHECK = 13, + SR__OPERATION__SESSION_SWITCH_DS = 14, + SR__OPERATION__SESSION_SET_OPTS = 15, + SR__OPERATION__VERSION_VERIFY = 16, + SR__OPERATION__LIST_SCHEMAS = 20, + SR__OPERATION__GET_SCHEMA = 21, + SR__OPERATION__MODULE_INSTALL = 22, + SR__OPERATION__FEATURE_ENABLE = 23, + SR__OPERATION__GET_ITEM = 30, + SR__OPERATION__GET_ITEMS = 31, + SR__OPERATION__GET_SUBTREE = 32, + SR__OPERATION__GET_SUBTREES = 33, + SR__OPERATION__GET_SUBTREE_CHUNK = 34, + SR__OPERATION__SET_ITEM = 40, + SR__OPERATION__DELETE_ITEM = 41, + SR__OPERATION__MOVE_ITEM = 42, + SR__OPERATION__SET_ITEM_STR = 43, + SR__OPERATION__VALIDATE = 50, + SR__OPERATION__COMMIT = 51, + SR__OPERATION__DISCARD_CHANGES = 52, + SR__OPERATION__COPY_CONFIG = 53, + SR__OPERATION__LOCK = 60, + SR__OPERATION__UNLOCK = 61, + SR__OPERATION__SUBSCRIBE = 70, + SR__OPERATION__UNSUBSCRIBE = 71, + SR__OPERATION__CHECK_ENABLED_RUNNING = 72, + SR__OPERATION__GET_CHANGES = 73, + SR__OPERATION__DATA_PROVIDE = 80, + SR__OPERATION__CHECK_EXEC_PERMISSION = 81, + SR__OPERATION__RPC = 82, + SR__OPERATION__ACTION = 83, + SR__OPERATION__EVENT_NOTIF = 84, + SR__OPERATION__EVENT_NOTIF_REPLAY = 85, + SR__OPERATION__UNSUBSCRIBE_DESTINATION = 101, + SR__OPERATION__COMMIT_TIMEOUT = 102, + SR__OPERATION__OPER_DATA_TIMEOUT = 103, + SR__OPERATION__INTERNAL_STATE_DATA = 104, + SR__OPERATION__NOTIF_STORE_CLEANUP = 105, + SR__OPERATION__DELAYED_MSG = 106, + SR__OPERATION__NACM_RELOAD = 107 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__OPERATION) +} Sr__Operation; + +/* --- messages --- */ + +/* + ** + * @brief Value of an item stored (or to be stored) in the datastore. + * Can be mapped to sr_val_t data structure from sysrepo library API. + */ +struct _Sr__Value +{ + ProtobufCMessage base; + char *xpath; + Sr__Value__Types type; + protobuf_c_boolean dflt; + char *binary_val; + char *bits_val; + protobuf_c_boolean has_bool_val; + protobuf_c_boolean bool_val; + protobuf_c_boolean has_decimal64_val; + double decimal64_val; + char *enum_val; + char *identityref_val; + char *instanceid_val; + protobuf_c_boolean has_int8_val; + int32_t int8_val; + protobuf_c_boolean has_int16_val; + int32_t int16_val; + protobuf_c_boolean has_int32_val; + int32_t int32_val; + protobuf_c_boolean has_int64_val; + int64_t int64_val; + char *string_val; + protobuf_c_boolean has_uint8_val; + uint32_t uint8_val; + protobuf_c_boolean has_uint16_val; + uint32_t uint16_val; + protobuf_c_boolean has_uint32_val; + uint32_t uint32_val; + protobuf_c_boolean has_uint64_val; + uint64_t uint64_val; + char *anyxml_val; + char *anydata_val; +}; +#define SR__VALUE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__value__descriptor) \ + , NULL, 0, 0, NULL, NULL, 0,0, 0,0, NULL, NULL, NULL, 0,0, 0,0, 0,0, 0,0, NULL, 0,0, 0,0, 0,0, 0,0, NULL, NULL } + + +/* + ** + * @brief Item stored (or to be stored) in the datastore represented as a tree node + * reflecting module schema. Can be mapped to sr_node_t data structure from sysrepo library API. + */ +struct _Sr__Node +{ + ProtobufCMessage base; + /* + **< Value of the node; member *xpath* is used to store node's name. + */ + Sr__Value *value; + /* + **< Name of the module that defines scheme of this node. + */ + char *module_name; + /* + **< Direct descendands of this node. + */ + size_t n_children; + Sr__Node **children; +}; +#define SR__NODE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__node__descriptor) \ + , NULL, NULL, 0,NULL } + + +/* + ** + * @brief Error message retuned from the Sysrepo Engine. + */ +struct _Sr__Error +{ + ProtobufCMessage base; + char *message; + char *xpath; +}; +#define SR__ERROR__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__error__descriptor) \ + , NULL, NULL } + + +/* + ** + * @brief Request for starting a session. Sent by sr_session_start API call. + */ +struct _Sr__SessionStartReq +{ + ProtobufCMessage base; + Sr__DataStore datastore; + char *user_name; + /* + **< Bitwise OR of SessionFlags. + */ + uint32_t options; + /* + **< Applicable if SESS_NOTIFICATION was specified. + */ + protobuf_c_boolean has_commit_id; + uint32_t commit_id; +}; +#define SR__SESSION_START_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_start_req__descriptor) \ + , 0, NULL, 0, 0,0 } + + +/* + ** + * @brief Response to session_start request. + */ +struct _Sr__SessionStartResp +{ + ProtobufCMessage base; + uint32_t session_id; +}; +#define SR__SESSION_START_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_start_resp__descriptor) \ + , 0 } + + +/* + ** + * @brief Request for stopping the session. Sent by sr_session_stop API call. + */ +struct _Sr__SessionStopReq +{ + ProtobufCMessage base; + uint32_t session_id; +}; +#define SR__SESSION_STOP_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_stop_req__descriptor) \ + , 0 } + + +/* + ** + * @brief Response to session_stop request. + */ +struct _Sr__SessionStopResp +{ + ProtobufCMessage base; + uint32_t session_id; +}; +#define SR__SESSION_STOP_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_stop_resp__descriptor) \ + , 0 } + + +/* + ** + * @brief Refreshes configuration data cached within the session. + * Sent by sr_session_refresh API call. + */ +struct _Sr__SessionRefreshReq +{ + ProtobufCMessage base; +}; +#define SR__SESSION_REFRESH_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_refresh_req__descriptor) \ + } + + +/* + ** + * @brief Response to sr_session_refresh request. + */ +struct _Sr__SessionRefreshResp +{ + ProtobufCMessage base; + size_t n_errors; + Sr__Error **errors; +}; +#define SR__SESSION_REFRESH_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_refresh_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Checks aliveness and validity of the session & connection tied to it. + * Sent by sr_session_check API call. + */ +struct _Sr__SessionCheckReq +{ + ProtobufCMessage base; +}; +#define SR__SESSION_CHECK_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_check_req__descriptor) \ + } + + +/* + ** + * @brief Response to sr_session_check request. + */ +struct _Sr__SessionCheckResp +{ + ProtobufCMessage base; + size_t n_errors; + Sr__Error **errors; +}; +#define SR__SESSION_CHECK_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_check_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Changes the datastore to which the session is tied to. + */ +struct _Sr__SessionSwitchDsReq +{ + ProtobufCMessage base; + Sr__DataStore datastore; +}; +#define SR__SESSION_SWITCH_DS_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_switch_ds_req__descriptor) \ + , 0 } + + +/* + ** + * @brief Response to sr_session_switch_ds request. + */ +struct _Sr__SessionSwitchDsResp +{ + ProtobufCMessage base; +}; +#define SR__SESSION_SWITCH_DS_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_switch_ds_resp__descriptor) \ + } + + +/* + ** + * @brief Request for modification of session options. + */ +struct _Sr__SessionSetOptsReq +{ + ProtobufCMessage base; + uint32_t options; +}; +#define SR__SESSION_SET_OPTS_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_set_opts_req__descriptor) \ + , 0 } + + +/* + ** + * @brief Response to sr_session_set_options. + */ +struct _Sr__SessionSetOptsResp +{ + ProtobufCMessage base; +}; +#define SR__SESSION_SET_OPTS_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__session_set_opts_resp__descriptor) \ + } + + +/* + ** + * @brief Request to verify version compatibility. + */ +struct _Sr__VersionVerifyReq +{ + ProtobufCMessage base; + char *soname; +}; +#define SR__VERSION_VERIFY_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__version_verify_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Response to version verification. + */ +struct _Sr__VersionVerifyResp +{ + ProtobufCMessage base; + /* + **< server-side SONAME version in case of versions incompatibility. + */ + char *soname; +}; +#define SR__VERSION_VERIFY_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__version_verify_resp__descriptor) \ + , NULL } + + +/* + ** + * @brief Schema revision details. + */ +struct _Sr__SchemaRevision +{ + ProtobufCMessage base; + /* + **< Latest revision date of the module. + */ + char *revision; + /* + **< Absolute path to file where the schema is stored (YANG format). + */ + char *file_path_yang; + /* + **< Absolute path to file where the schema is stored (.yin format). + */ + char *file_path_yin; +}; +#define SR__SCHEMA_REVISION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__schema_revision__descriptor) \ + , NULL, NULL, NULL } + + +/* + ** + * @brief Schema submodule information. + */ +struct _Sr__SchemaSubmodule +{ + ProtobufCMessage base; + /* + **< Submodule name + */ + char *submodule_name; + /* + **< Revision of the submodule + */ + Sr__SchemaRevision *revision; +}; +#define SR__SCHEMA_SUBMODULE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__schema_submodule__descriptor) \ + , NULL, NULL } + + +/* + ** + * @brief Information about a schema installed in sysrepo datastore. + */ +struct _Sr__Schema +{ + ProtobufCMessage base; + /* + **< Name of the module. + */ + char *module_name; + /* + **< Namespace of the module. + */ + char *ns; + /* + **< Prefix of he module. + */ + char *prefix; + /* + **< TRUE only for explicitly installed modules (those are always implemented). + */ + protobuf_c_boolean installed; + /* + **< TRUE for implemented modules (do not have to be installed if they have augments, + *deviations or are targets for leafrefs of other implemented modules). + */ + protobuf_c_boolean implemented; + /* + **< Revision of the module + */ + Sr__SchemaRevision *revision; + /* + **< Submodules + */ + size_t n_submodules; + Sr__SchemaSubmodule **submodules; + /* + **< Features enabled for the module + */ + size_t n_enabled_features; + char **enabled_features; +}; +#define SR__SCHEMA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__schema__descriptor) \ + , NULL, NULL, NULL, 0, 0, NULL, 0,NULL, 0,NULL } + + +/* + ** + * @brief Retrieves an array of schemas installed in the sysrepo datastore. + * Sent by sr_list_schemas API call. + */ +struct _Sr__ListSchemasReq +{ + ProtobufCMessage base; +}; +#define SR__LIST_SCHEMAS_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__list_schemas_req__descriptor) \ + } + + +/* + ** + * @brief Response to sr_list_schemas request. + */ +struct _Sr__ListSchemasResp +{ + ProtobufCMessage base; + size_t n_schemas; + Sr__Schema **schemas; +}; +#define SR__LIST_SCHEMAS_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__list_schemas_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Retrieves the content of specified schema file. + * Sent by sr_get_schema API call. + */ +struct _Sr__GetSchemaReq +{ + ProtobufCMessage base; + char *module_name; + char *revision; + char *submodule_name; + char *submodule_revision; + protobuf_c_boolean yang_format; +}; +#define SR__GET_SCHEMA_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_schema_req__descriptor) \ + , NULL, NULL, NULL, NULL, 0 } + + +/* + ** + * @brief Response to sr_get_schema request. + */ +struct _Sr__GetSchemaResp +{ + ProtobufCMessage base; + char *schema_content; +}; +#define SR__GET_SCHEMA_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_schema_resp__descriptor) \ + , NULL } + + +/* + ** + * @brief Retrieves a single data element stored under provided path. + * Sent by sr_get_item API call. + */ +struct _Sr__GetItemReq +{ + ProtobufCMessage base; + char *xpath; +}; +#define SR__GET_ITEM_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_item_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Response to get_item request. + */ +struct _Sr__GetItemResp +{ + ProtobufCMessage base; + Sr__Value *value; +}; +#define SR__GET_ITEM_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_item_resp__descriptor) \ + , NULL } + + +/* + ** + * @brief Retrieves an array of data elements stored under provided path. + * Sent by sr_get_items and sr_get_items_iter API calls. + */ +struct _Sr__GetItemsReq +{ + ProtobufCMessage base; + char *xpath; + /* + * The options below are applicable only for sr_get_items_iter + * (not set by sr_get_items). + */ + protobuf_c_boolean has_limit; + uint32_t limit; + protobuf_c_boolean has_offset; + uint32_t offset; +}; +#define SR__GET_ITEMS_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_items_req__descriptor) \ + , NULL, 0,0, 0,0 } + + +/* + ** + * @brief Response to get_items / sr_get_items_iter request. + */ +struct _Sr__GetItemsResp +{ + ProtobufCMessage base; + size_t n_values; + Sr__Value **values; +}; +#define SR__GET_ITEMS_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_items_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Retrieves a single subtree whose root is stored under provided path. + * Sent by sr_get_subtree API call. + */ +struct _Sr__GetSubtreeReq +{ + ProtobufCMessage base; + char *xpath; +}; +#define SR__GET_SUBTREE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Response to sr_get_subtree request. + */ +struct _Sr__GetSubtreeResp +{ + ProtobufCMessage base; + Sr__Node *tree; +}; +#define SR__GET_SUBTREE_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_resp__descriptor) \ + , NULL } + + +/* + ** + * @brief Retrieves an array of subtrees whose root nodes match provided path. + * Sent by sr_get_subtrees API call. + */ +struct _Sr__GetSubtreesReq +{ + ProtobufCMessage base; + char *xpath; +}; +#define SR__GET_SUBTREES_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtrees_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Response to sr_get_subtrees request. + */ +struct _Sr__GetSubtreesResp +{ + ProtobufCMessage base; + size_t n_trees; + Sr__Node **trees; +}; +#define SR__GET_SUBTREES_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtrees_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Retrieves a chunk of a single or multiple subtrees. + * A subtree chunk is also a tree, where the root node is the node referenced by XPath, + * the next level consists of its children skipping the first "slice_offset" nodes and including + * at most "slice_limit" nodes, while the remaining (depth_limit-2) levels always start with + * the first child (slice_offset is ignored) and include at most "child_limit" nodes. + * The chunk consists of at most "depth_limit" levels. + * @note Order of child nodes depends on the libyang implementation. + */ +struct _Sr__GetSubtreeChunkReq +{ + ProtobufCMessage base; + char *xpath; + protobuf_c_boolean single; + uint32_t slice_offset; + uint32_t slice_width; + uint32_t child_limit; + uint32_t depth_limit; +}; +#define SR__GET_SUBTREE_CHUNK_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_chunk_req__descriptor) \ + , NULL, 0, 0, 0, 0, 0 } + + +/* + ** + * @brief Response to sr_get_subtree_chunk request. + */ +struct _Sr__GetSubtreeChunkResp +{ + ProtobufCMessage base; + /* + **< JSON node-id of the root node for each subtree chunk + */ + size_t n_xpath; + char **xpath; + /* + **< first chunk may carry mutliple trees + */ + size_t n_chunk; + Sr__Node **chunk; +}; +#define SR__GET_SUBTREE_CHUNK_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_chunk_resp__descriptor) \ + , 0,NULL, 0,NULL } + + +/* + ** + * @brief Sets the value of the leaf, leaf-list or presence container. + * Sent by sr_set_item API call. + */ +struct _Sr__SetItemReq +{ + ProtobufCMessage base; + char *xpath; + Sr__Value *value; + /* + **< Bitwise OR of EditFlags + */ + uint32_t options; +}; +#define SR__SET_ITEM_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_req__descriptor) \ + , NULL, NULL, 0 } + + +/* + ** + * @brief Response to sr_set_item request. + */ +struct _Sr__SetItemResp +{ + ProtobufCMessage base; +}; +#define SR__SET_ITEM_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_resp__descriptor) \ + } + + +/* + ** + * @brief Sets the value of the leaf, leaf-list or presence container. + * The value is transferred as string. + * Sent by sr_set_item_str API call. + */ +struct _Sr__SetItemStrReq +{ + ProtobufCMessage base; + char *xpath; + char *value; + /* + **< Bitwise OR of EditFlags + */ + uint32_t options; +}; +#define SR__SET_ITEM_STR_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_str_req__descriptor) \ + , NULL, NULL, 0 } + + +/* + ** + * @brief Response to sr_set_item_str request. + */ +struct _Sr__SetItemStrResp +{ + ProtobufCMessage base; +}; +#define SR__SET_ITEM_STR_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_str_resp__descriptor) \ + } + + +/* + ** + * @brief Deletes the nodes under the specified xpath. + * Sent by sr_delete_item API call. + */ +struct _Sr__DeleteItemReq +{ + ProtobufCMessage base; + char *xpath; + /* + **< Bitwise OR of EditFlags + */ + uint32_t options; +}; +#define SR__DELETE_ITEM_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__delete_item_req__descriptor) \ + , NULL, 0 } + + +/* + ** + * @brief Response to sr_delete_item request. + */ +struct _Sr__DeleteItemResp +{ + ProtobufCMessage base; +}; +#define SR__DELETE_ITEM_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__delete_item_resp__descriptor) \ + } + + +/* + ** + * @brief Move the instance of an ordered list in specified direction. + * Sent by sr_move_item API call. + */ +struct _Sr__MoveItemReq +{ + ProtobufCMessage base; + char *xpath; + Sr__MoveItemReq__MovePosition position; + char *relative_item; +}; +#define SR__MOVE_ITEM_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__move_item_req__descriptor) \ + , NULL, 0, NULL } + + +/* + ** + * @brief Response to sr_move_item request. + */ +struct _Sr__MoveItemResp +{ + ProtobufCMessage base; +}; +#define SR__MOVE_ITEM_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__move_item_resp__descriptor) \ + } + + +/* + ** + * @brief Perform the validation of changes made in current session, but do not + * commit nor discard them. Sent by sr_validate API call. + */ +struct _Sr__ValidateReq +{ + ProtobufCMessage base; +}; +#define SR__VALIDATE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__validate_req__descriptor) \ + } + + +/* + ** + * @brief Response to sr_validate request. + */ +struct _Sr__ValidateResp +{ + ProtobufCMessage base; + size_t n_errors; + Sr__Error **errors; +}; +#define SR__VALIDATE_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__validate_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Apply changes made in current session. + * Sent by sr_commit API call. + */ +struct _Sr__CommitReq +{ + ProtobufCMessage base; +}; +#define SR__COMMIT_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_req__descriptor) \ + } + + +/* + ** + * @brief Response to sr_commit request. + */ +struct _Sr__CommitResp +{ + ProtobufCMessage base; + size_t n_errors; + Sr__Error **errors; +}; +#define SR__COMMIT_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Discard non-committed changes made in current session. + * Sent by sr_discard_changes API call. + */ +struct _Sr__DiscardChangesReq +{ + ProtobufCMessage base; +}; +#define SR__DISCARD_CHANGES_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__discard_changes_req__descriptor) \ + } + + +/* + ** + * @brief Response to sr_discard_changes request. + */ +struct _Sr__DiscardChangesResp +{ + ProtobufCMessage base; +}; +#define SR__DISCARD_CHANGES_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__discard_changes_resp__descriptor) \ + } + + +/* + ** + * @brief Replaces an entire configuration datastore with the contents of + * another complete configuration datastore. Sent by sr_copy_config request. + */ +struct _Sr__CopyConfigReq +{ + ProtobufCMessage base; + Sr__DataStore src_datastore; + Sr__DataStore dst_datastore; + /* + **< If not specified, the operation is performed on all + *modules that are currently active in the source datastore + */ + char *module_name; +}; +#define SR__COPY_CONFIG_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__copy_config_req__descriptor) \ + , 0, 0, NULL } + + +/* + ** + * @brief Response to sr_copy_config request. + */ +struct _Sr__CopyConfigResp +{ + ProtobufCMessage base; + size_t n_errors; + Sr__Error **errors; +}; +#define SR__COPY_CONFIG_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__copy_config_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Locks specified data model or the datastore which the session is tied to. + * Sent by sr_lock_datastore and sr_lock_model API calls. + */ +struct _Sr__LockReq +{ + ProtobufCMessage base; + /* + **< If module name is not set, LockReq locks whole datastore. + */ + char *module_name; +}; +#define SR__LOCK_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__lock_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Response to sr_lock_datastore or sr_lock_model request. + */ +struct _Sr__LockResp +{ + ProtobufCMessage base; +}; +#define SR__LOCK_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__lock_resp__descriptor) \ + } + + +/* + ** + * @brief Unlocks specified data model or the datastore which the session is tied to. + * Sent by sr_unlock_datastore and sr_unlock_model API calls. + */ +struct _Sr__UnlockReq +{ + ProtobufCMessage base; + /* + **< If module name is not set, UnlockReq unlocks whole datastore. + */ + char *module_name; +}; +#define SR__UNLOCK_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__unlock_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Response to sr_lock_datastore or sr_lock_model request. + */ +struct _Sr__UnlockResp +{ + ProtobufCMessage base; +}; +#define SR__UNLOCK_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__unlock_resp__descriptor) \ + } + + +struct _Sr__SubscribeReq +{ + ProtobufCMessage base; + Sr__SubscriptionType type; + char *destination; + uint32_t subscription_id; + char *module_name; + char *xpath; + protobuf_c_boolean has_notif_event; + Sr__NotificationEvent notif_event; + protobuf_c_boolean has_priority; + uint32_t priority; + protobuf_c_boolean has_enable_running; + protobuf_c_boolean enable_running; + protobuf_c_boolean has_enable_event; + protobuf_c_boolean enable_event; + Sr__ApiVariant api_variant; +}; +#define SR__SUBSCRIBE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__subscribe_req__descriptor) \ + , 0, NULL, 0, NULL, NULL, 0,0, 0,0, 0,0, 0,0, 0 } + + +struct _Sr__SubscribeResp +{ + ProtobufCMessage base; +}; +#define SR__SUBSCRIBE_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__subscribe_resp__descriptor) \ + } + + +struct _Sr__UnsubscribeReq +{ + ProtobufCMessage base; + Sr__SubscriptionType type; + char *destination; + uint32_t subscription_id; + char *module_name; +}; +#define SR__UNSUBSCRIBE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_req__descriptor) \ + , 0, NULL, 0, NULL } + + +struct _Sr__UnsubscribeResp +{ + ProtobufCMessage base; +}; +#define SR__UNSUBSCRIBE_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_resp__descriptor) \ + } + + +/* + ** + * @brief Checks whether the module has any enabled subtree. + * Sent by sr_check_enabled_running. + */ +struct _Sr__CheckEnabledRunningReq +{ + ProtobufCMessage base; + char *module_name; +}; +#define SR__CHECK_ENABLED_RUNNING_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__check_enabled_running_req__descriptor) \ + , NULL } + + +struct _Sr__CheckEnabledRunningResp +{ + ProtobufCMessage base; + protobuf_c_boolean enabled; +}; +#define SR__CHECK_ENABLED_RUNNING_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__check_enabled_running_resp__descriptor) \ + , 0 } + + +struct _Sr__ModuleInstallNotification +{ + ProtobufCMessage base; + char *module_name; + char *revision; + Sr__ModuleState state; +}; +#define SR__MODULE_INSTALL_NOTIFICATION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_notification__descriptor) \ + , NULL, NULL, 0 } + + +struct _Sr__FeatureEnableNotification +{ + ProtobufCMessage base; + char *module_name; + char *feature_name; + protobuf_c_boolean enabled; +}; +#define SR__FEATURE_ENABLE_NOTIFICATION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_notification__descriptor) \ + , NULL, NULL, 0 } + + +struct _Sr__ModuleChangeNotification +{ + ProtobufCMessage base; + Sr__NotificationEvent event; + char *module_name; +}; +#define SR__MODULE_CHANGE_NOTIFICATION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__module_change_notification__descriptor) \ + , 0, NULL } + + +struct _Sr__SubtreeChangeNotification +{ + ProtobufCMessage base; + Sr__NotificationEvent event; + char *xpath; +}; +#define SR__SUBTREE_CHANGE_NOTIFICATION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__subtree_change_notification__descriptor) \ + , 0, NULL } + + +struct _Sr__Change +{ + ProtobufCMessage base; + Sr__ChangeOperation changeoperation; + Sr__Value *new_value; + Sr__Value *old_value; +}; +#define SR__CHANGE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__change__descriptor) \ + , 0, NULL, NULL } + + +/* + ** + * @brief Retrieves an array of changes made under provided path. + * Sent by sr_get_changes_iter or sr_get_change_next API calls. + */ +struct _Sr__GetChangesReq +{ + ProtobufCMessage base; + char *xpath; + uint32_t limit; + uint32_t offset; +}; +#define SR__GET_CHANGES_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_changes_req__descriptor) \ + , NULL, 0, 0 } + + +/* + ** + * @brief Response to get_changes request. + */ +struct _Sr__GetChangesResp +{ + ProtobufCMessage base; + size_t n_changes; + Sr__Change **changes; +}; +#define SR__GET_CHANGES_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__get_changes_resp__descriptor) \ + , 0,NULL } + + +/* + ** + * @brief Sends a request to check if the owner of this session is authorized to invoke + * the protocol operation referenced by the xpath. + * Sent by sr_check_exec_permission. + */ +struct _Sr__CheckExecPermReq +{ + ProtobufCMessage base; + char *xpath; +}; +#define SR__CHECK_EXEC_PERM_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__check_exec_perm_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Response to sr_check_exec_permission request. + */ +struct _Sr__CheckExecPermResp +{ + ProtobufCMessage base; + protobuf_c_boolean permitted; +}; +#define SR__CHECK_EXEC_PERM_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__check_exec_perm_resp__descriptor) \ + , 0 } + + +/* + ** + * @brief Sends a RPC / action request into the datastore, will be delivered to the RPC subscriber. + * Sent by sr_rpc_send / sr_rpc_send_tree and sr_action_send / sr_action_send_tree API calls. + */ +struct _Sr__RPCReq +{ + ProtobufCMessage base; + protobuf_c_boolean action; + char *xpath; + /* + **< which API variant was used to send RPC req. + */ + Sr__ApiVariant orig_api_variant; + size_t n_input; + Sr__Value **input; + size_t n_input_tree; + Sr__Node **input_tree; + char *subscriber_address; + protobuf_c_boolean has_subscription_id; + uint32_t subscription_id; +}; +#define SR__RPCREQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__rpcreq__descriptor) \ + , 0, NULL, 0, 0,NULL, 0,NULL, NULL, 0,0 } + + +/* + ** + * @brief Response to sr_rpc_send / sr_rpc_send_tree or sr_action_send / sr_action_send_tree request. + */ +struct _Sr__RPCResp +{ + ProtobufCMessage base; + protobuf_c_boolean action; + char *xpath; + /* + **< which API variant was used to send RPC req. + */ + Sr__ApiVariant orig_api_variant; + size_t n_output; + Sr__Value **output; + size_t n_output_tree; + Sr__Node **output_tree; +}; +#define SR__RPCRESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__rpcresp__descriptor) \ + , 0, NULL, 0, 0,NULL, 0,NULL } + + +/* + ** + * @brief Sends an event notification into the datastore, will be delivered to all notification subscribers. + * Sent by sr_event_notif_send API call. + */ +struct _Sr__EventNotifReq +{ + ProtobufCMessage base; + Sr__EventNotifReq__NotifType type; + /* + **< Bitwise OR of NotifFlags. + */ + uint32_t options; + char *xpath; + size_t n_values; + Sr__Value **values; + size_t n_trees; + Sr__Node **trees; + uint64_t timestamp; + char *subscriber_address; + protobuf_c_boolean has_subscription_id; + uint32_t subscription_id; + protobuf_c_boolean do_not_send_reply; +}; +#define SR__EVENT_NOTIF_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_req__descriptor) \ + , 0, 0, NULL, 0,NULL, 0,NULL, 0, NULL, 0,0, 0 } + + +/* + ** + * @brief Response to sr_event_notif_send request. + */ +struct _Sr__EventNotifResp +{ + ProtobufCMessage base; +}; +#define SR__EVENT_NOTIF_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_resp__descriptor) \ + } + + +/* + ** + * @brief Sends a request to replay event notifications stored in the datastore. + * Sent by sr_event_notif_replay API call. + */ +struct _Sr__EventNotifReplayReq +{ + ProtobufCMessage base; + char *xpath; + uint64_t start_time; + uint64_t stop_time; + char *subscriber_address; + uint32_t subscription_id; + Sr__ApiVariant api_variant; +}; +#define SR__EVENT_NOTIF_REPLAY_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_replay_req__descriptor) \ + , NULL, 0, 0, NULL, 0, 0 } + + +/* + ** + * @brief Response to sr_event_notif_replay request. + */ +struct _Sr__EventNotifReplayResp +{ + ProtobufCMessage base; +}; +#define SR__EVENT_NOTIF_REPLAY_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_replay_resp__descriptor) \ + } + + +/* + ** + * @brief Requests operational data under given path form an operational data + * provider. + */ +struct _Sr__DataProvideReq +{ + ProtobufCMessage base; + char *xpath; + char *subscriber_address; + uint32_t subscription_id; + uint64_t request_id; +}; +#define SR__DATA_PROVIDE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__data_provide_req__descriptor) \ + , NULL, NULL, 0, 0 } + + +/* + ** + * @brief Response to a request of operational data under given path form an + * operational data provider. + */ +struct _Sr__DataProvideResp +{ + ProtobufCMessage base; + char *xpath; + size_t n_values; + Sr__Value **values; + uint64_t request_id; +}; +#define SR__DATA_PROVIDE_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__data_provide_resp__descriptor) \ + , NULL, 0,NULL, 0 } + + +/* + ** + * @brief Requests installation / uinstallation of specified YANG model. + * Sent by sr_module_install internal API calls. + */ +struct _Sr__ModuleInstallReq +{ + ProtobufCMessage base; + char *module_name; + char *revision; + char *file_name; + protobuf_c_boolean installed; +}; +#define SR__MODULE_INSTALL_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_req__descriptor) \ + , NULL, NULL, NULL, 0 } + + +/* + ** + * @brief Response to sr_module_install request. + */ +struct _Sr__ModuleInstallResp +{ + ProtobufCMessage base; +}; +#define SR__MODULE_INSTALL_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_resp__descriptor) \ + } + + +/* + ** + * @brief Requests enabling / disabling of specified YANG feature within the + * YANG model. Sent by sr_feature_enable internal API calls. + */ +struct _Sr__FeatureEnableReq +{ + ProtobufCMessage base; + char *module_name; + char *feature_name; + protobuf_c_boolean enabled; +}; +#define SR__FEATURE_ENABLE_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_req__descriptor) \ + , NULL, NULL, 0 } + + +/* + ** + * @brief Response to sr_feature_enable request. + */ +struct _Sr__FeatureEnableResp +{ + ProtobufCMessage base; +}; +#define SR__FEATURE_ENABLE_RESP__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_resp__descriptor) \ + } + + +/* + ** + * @brief Internal request to unsubscribe all subscriptions of a subscriber on given destination address. + */ +struct _Sr__UnsubscribeDestinationReq +{ + ProtobufCMessage base; + char *destination; +}; +#define SR__UNSUBSCRIBE_DESTINATION_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_destination_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Internal request to timeout a commit, if it hasn't been terminated yet. + */ +struct _Sr__CommitTimeoutReq +{ + ProtobufCMessage base; + uint32_t commit_id; + protobuf_c_boolean expired; +}; +#define SR__COMMIT_TIMEOUT_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_timeout_req__descriptor) \ + , 0, 0 } + + +/* + ** + * @brief Internal request to timeout a request for operational data, if it hasn't been terminated yet. + */ +struct _Sr__OperDataTimeoutReq +{ + ProtobufCMessage base; + uint64_t request_id; +}; +#define SR__OPER_DATA_TIMEOUT_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__oper_data_timeout_req__descriptor) \ + , 0 } + + +/* + ** + * @brief Internal request for internal state data (state data provided by Sysrepo Engine itself). + */ +struct _Sr__InternalStateDataReq +{ + ProtobufCMessage base; + uint64_t request_id; + char *xpath; +}; +#define SR__INTERNAL_STATE_DATA_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__internal_state_data_req__descriptor) \ + , 0, NULL } + + +/* + ** + * @brief Internal request to cleanup aged notifications in the Notification Store. + */ +struct _Sr__NotifStoreCleanupReq +{ + ProtobufCMessage base; +}; +#define SR__NOTIF_STORE_CLEANUP_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__notif_store_cleanup_req__descriptor) \ + } + + +/* + ** + * @brief Message to be delivered to the client after some timeout. + */ +struct _Sr__DelayedMsgReq +{ + ProtobufCMessage base; + Sr__Msg *message; +}; +#define SR__DELAYED_MSG_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__delayed_msg_req__descriptor) \ + , NULL } + + +/* + ** + * @brief Internal request to reload NACM configuration from the running datastore. + */ +struct _Sr__NacmReloadReq +{ + ProtobufCMessage base; +}; +#define SR__NACM_RELOAD_REQ__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__nacm_reload_req__descriptor) \ + } + + +/* + ** + * @brief Request for an operation. + */ +struct _Sr__Request +{ + ProtobufCMessage base; + /* + * Request ID used internally by sysrepo + */ + uint64_t _id; + Sr__Operation operation; + Sr__SessionStartReq *session_start_req; + Sr__SessionStopReq *session_stop_req; + Sr__SessionRefreshReq *session_refresh_req; + Sr__SessionCheckReq *session_check_req; + Sr__SessionSwitchDsReq *session_switch_ds_req; + Sr__SessionSetOptsReq *session_set_opts_req; + Sr__VersionVerifyReq *version_verify_req; + Sr__ListSchemasReq *list_schemas_req; + Sr__GetSchemaReq *get_schema_req; + Sr__ModuleInstallReq *module_install_req; + Sr__FeatureEnableReq *feature_enable_req; + Sr__GetItemReq *get_item_req; + Sr__GetItemsReq *get_items_req; + Sr__GetSubtreeReq *get_subtree_req; + Sr__GetSubtreesReq *get_subtrees_req; + Sr__GetSubtreeChunkReq *get_subtree_chunk_req; + Sr__SetItemReq *set_item_req; + Sr__DeleteItemReq *delete_item_req; + Sr__MoveItemReq *move_item_req; + Sr__SetItemStrReq *set_item_str_req; + Sr__ValidateReq *validate_req; + Sr__CommitReq *commit_req; + Sr__DiscardChangesReq *discard_changes_req; + Sr__CopyConfigReq *copy_config_req; + Sr__LockReq *lock_req; + Sr__UnlockReq *unlock_req; + Sr__SubscribeReq *subscribe_req; + Sr__UnsubscribeReq *unsubscribe_req; + Sr__CheckEnabledRunningReq *check_enabled_running_req; + Sr__GetChangesReq *get_changes_req; + Sr__DataProvideReq *data_provide_req; + Sr__CheckExecPermReq *check_exec_perm_req; + Sr__RPCReq *rpc_req; + Sr__EventNotifReq *event_notif_req; + Sr__EventNotifReplayReq *event_notif_replay_req; +}; +#define SR__REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__request__descriptor) \ + , 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } + + +/* + ** + * @brief Response to the received request. + */ +struct _Sr__Response +{ + ProtobufCMessage base; + Sr__Operation operation; + /* + **< Result of the operation. 0 on success, non-zero values map to sr_error_t enum in sysrepo.h. + */ + uint32_t result; + /* + **< Additional error information. + */ + Sr__Error *error; + Sr__SessionStartResp *session_start_resp; + Sr__SessionStopResp *session_stop_resp; + Sr__SessionRefreshResp *session_refresh_resp; + Sr__SessionCheckResp *session_check_resp; + Sr__SessionSwitchDsResp *session_switch_ds_resp; + Sr__SessionSetOptsResp *session_set_opts_resp; + Sr__VersionVerifyResp *version_verify_resp; + Sr__ListSchemasResp *list_schemas_resp; + Sr__GetSchemaResp *get_schema_resp; + Sr__ModuleInstallResp *module_install_resp; + Sr__FeatureEnableResp *feature_enable_resp; + Sr__GetItemResp *get_item_resp; + Sr__GetItemsResp *get_items_resp; + Sr__GetSubtreeResp *get_subtree_resp; + Sr__GetSubtreesResp *get_subtrees_resp; + Sr__GetSubtreeChunkResp *get_subtree_chunk_resp; + Sr__SetItemResp *set_item_resp; + Sr__DeleteItemResp *delete_item_resp; + Sr__MoveItemResp *move_item_resp; + Sr__SetItemStrResp *set_item_str_resp; + Sr__ValidateResp *validate_resp; + Sr__CommitResp *commit_resp; + Sr__DiscardChangesResp *discard_changes_resp; + Sr__CopyConfigResp *copy_config_resp; + Sr__LockResp *lock_resp; + Sr__UnlockResp *unlock_resp; + Sr__SubscribeResp *subscribe_resp; + Sr__UnsubscribeResp *unsubscribe_resp; + Sr__CheckEnabledRunningResp *check_enabled_running_resp; + Sr__GetChangesResp *get_changes_resp; + Sr__DataProvideResp *data_provide_resp; + Sr__CheckExecPermResp *check_exec_perm_resp; + Sr__RPCResp *rpc_resp; + Sr__EventNotifResp *event_notif_resp; + Sr__EventNotifReplayResp *event_notif_replay_resp; +}; +#define SR__RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__response__descriptor) \ + , 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } + + +/* + ** + * @brief Notification about an event that occurred in the datastore. + */ +struct _Sr__Notification +{ + ProtobufCMessage base; + Sr__SubscriptionType type; + char *destination_address; + char *source_address; + uint32_t source_pid; + uint32_t subscription_id; + protobuf_c_boolean has_commit_id; + uint32_t commit_id; + Sr__ModuleInstallNotification *module_install_notif; + Sr__FeatureEnableNotification *feature_enable_notif; + Sr__ModuleChangeNotification *module_change_notif; + Sr__SubtreeChangeNotification *subtree_change_notif; +}; +#define SR__NOTIFICATION__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__notification__descriptor) \ + , 0, NULL, NULL, 0, 0, 0,0, NULL, NULL, NULL, NULL } + + +/* + ** + * @brief Notification Acknowledgment. + */ +struct _Sr__NotificationAck +{ + ProtobufCMessage base; + /* + **< Original notification. + */ + Sr__Notification *notif; + /* + **< Result of the notification (success / error code). + */ + uint32_t result; + /* + **< Additional error information. + */ + Sr__Error *error; + /* + **< If the result is error and this flag is set to true abort notification + * will not be delivered to this subscriber + * (Subscriber doesn't want notification about changes that he refused). + */ + protobuf_c_boolean do_not_send_abort; +}; +#define SR__NOTIFICATION_ACK__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__notification_ack__descriptor) \ + , NULL, 0, NULL, 0 } + + +/* + ** + * @brief Internal request sent by sysrepo. Should not be used from the public API. + */ +struct _Sr__InternalRequest +{ + ProtobufCMessage base; + Sr__Operation operation; + protobuf_c_boolean has_postpone_timeout; + uint32_t postpone_timeout; + Sr__UnsubscribeDestinationReq *unsubscribe_dst_req; + Sr__CommitTimeoutReq *commit_timeout_req; + Sr__OperDataTimeoutReq *oper_data_timeout_req; + Sr__InternalStateDataReq *internal_state_data_req; + Sr__NotifStoreCleanupReq *notif_store_cleanup_req; + Sr__DelayedMsgReq *delayed_msg_req; + Sr__NacmReloadReq *nacm_reload_req; +}; +#define SR__INTERNAL_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__internal_request__descriptor) \ + , 0, 0,0, NULL, NULL, NULL, NULL, NULL, NULL, NULL } + + +/* + ** + * @brief Umbrella sysrepo message used for communication between sysrepo + * engine and client library. + */ +struct _Sr__Msg +{ + ProtobufCMessage base; + /* + **< Indicates type of the message. + */ + Sr__Msg__MsgType type; + /* + **< Session identifier. Can be 0 (value is ignored) for session_start and version_verify requests. + */ + uint32_t session_id; + /* + **< Filled in in case of type == REQUEST. + */ + Sr__Request *request; + /* + **< Filled in in case of type == RESPONSE. + */ + Sr__Response *response; + /* + **< Filled in in case of type == NOTIFICATION. + */ + Sr__Notification *notification; + /* + **< Filled in in case of type == NOTIFICATION_ACK + */ + Sr__NotificationAck *notification_ack; + /* + **< Filled in in case of type == INTERNAL. + */ + Sr__InternalRequest *internal_request; + /* + **< Not part of the protocol. Used internally by Sysrepo to store a pointer to memory context. + */ + uint64_t _sysrepo_mem_ctx; +}; +#define SR__MSG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sr__msg__descriptor) \ + , 0, 0, NULL, NULL, NULL, NULL, NULL, 0 } + + +/* Sr__Value methods */ +void sr__value__init + (Sr__Value *message); +size_t sr__value__get_packed_size + (const Sr__Value *message); +size_t sr__value__pack + (const Sr__Value *message, + uint8_t *out); +size_t sr__value__pack_to_buffer + (const Sr__Value *message, + ProtobufCBuffer *buffer); +Sr__Value * + sr__value__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__value__free_unpacked + (Sr__Value *message, + ProtobufCAllocator *allocator); +/* Sr__Node methods */ +void sr__node__init + (Sr__Node *message); +size_t sr__node__get_packed_size + (const Sr__Node *message); +size_t sr__node__pack + (const Sr__Node *message, + uint8_t *out); +size_t sr__node__pack_to_buffer + (const Sr__Node *message, + ProtobufCBuffer *buffer); +Sr__Node * + sr__node__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__node__free_unpacked + (Sr__Node *message, + ProtobufCAllocator *allocator); +/* Sr__Error methods */ +void sr__error__init + (Sr__Error *message); +size_t sr__error__get_packed_size + (const Sr__Error *message); +size_t sr__error__pack + (const Sr__Error *message, + uint8_t *out); +size_t sr__error__pack_to_buffer + (const Sr__Error *message, + ProtobufCBuffer *buffer); +Sr__Error * + sr__error__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__error__free_unpacked + (Sr__Error *message, + ProtobufCAllocator *allocator); +/* Sr__SessionStartReq methods */ +void sr__session_start_req__init + (Sr__SessionStartReq *message); +size_t sr__session_start_req__get_packed_size + (const Sr__SessionStartReq *message); +size_t sr__session_start_req__pack + (const Sr__SessionStartReq *message, + uint8_t *out); +size_t sr__session_start_req__pack_to_buffer + (const Sr__SessionStartReq *message, + ProtobufCBuffer *buffer); +Sr__SessionStartReq * + sr__session_start_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_start_req__free_unpacked + (Sr__SessionStartReq *message, + ProtobufCAllocator *allocator); +/* Sr__SessionStartResp methods */ +void sr__session_start_resp__init + (Sr__SessionStartResp *message); +size_t sr__session_start_resp__get_packed_size + (const Sr__SessionStartResp *message); +size_t sr__session_start_resp__pack + (const Sr__SessionStartResp *message, + uint8_t *out); +size_t sr__session_start_resp__pack_to_buffer + (const Sr__SessionStartResp *message, + ProtobufCBuffer *buffer); +Sr__SessionStartResp * + sr__session_start_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_start_resp__free_unpacked + (Sr__SessionStartResp *message, + ProtobufCAllocator *allocator); +/* Sr__SessionStopReq methods */ +void sr__session_stop_req__init + (Sr__SessionStopReq *message); +size_t sr__session_stop_req__get_packed_size + (const Sr__SessionStopReq *message); +size_t sr__session_stop_req__pack + (const Sr__SessionStopReq *message, + uint8_t *out); +size_t sr__session_stop_req__pack_to_buffer + (const Sr__SessionStopReq *message, + ProtobufCBuffer *buffer); +Sr__SessionStopReq * + sr__session_stop_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_stop_req__free_unpacked + (Sr__SessionStopReq *message, + ProtobufCAllocator *allocator); +/* Sr__SessionStopResp methods */ +void sr__session_stop_resp__init + (Sr__SessionStopResp *message); +size_t sr__session_stop_resp__get_packed_size + (const Sr__SessionStopResp *message); +size_t sr__session_stop_resp__pack + (const Sr__SessionStopResp *message, + uint8_t *out); +size_t sr__session_stop_resp__pack_to_buffer + (const Sr__SessionStopResp *message, + ProtobufCBuffer *buffer); +Sr__SessionStopResp * + sr__session_stop_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_stop_resp__free_unpacked + (Sr__SessionStopResp *message, + ProtobufCAllocator *allocator); +/* Sr__SessionRefreshReq methods */ +void sr__session_refresh_req__init + (Sr__SessionRefreshReq *message); +size_t sr__session_refresh_req__get_packed_size + (const Sr__SessionRefreshReq *message); +size_t sr__session_refresh_req__pack + (const Sr__SessionRefreshReq *message, + uint8_t *out); +size_t sr__session_refresh_req__pack_to_buffer + (const Sr__SessionRefreshReq *message, + ProtobufCBuffer *buffer); +Sr__SessionRefreshReq * + sr__session_refresh_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_refresh_req__free_unpacked + (Sr__SessionRefreshReq *message, + ProtobufCAllocator *allocator); +/* Sr__SessionRefreshResp methods */ +void sr__session_refresh_resp__init + (Sr__SessionRefreshResp *message); +size_t sr__session_refresh_resp__get_packed_size + (const Sr__SessionRefreshResp *message); +size_t sr__session_refresh_resp__pack + (const Sr__SessionRefreshResp *message, + uint8_t *out); +size_t sr__session_refresh_resp__pack_to_buffer + (const Sr__SessionRefreshResp *message, + ProtobufCBuffer *buffer); +Sr__SessionRefreshResp * + sr__session_refresh_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_refresh_resp__free_unpacked + (Sr__SessionRefreshResp *message, + ProtobufCAllocator *allocator); +/* Sr__SessionCheckReq methods */ +void sr__session_check_req__init + (Sr__SessionCheckReq *message); +size_t sr__session_check_req__get_packed_size + (const Sr__SessionCheckReq *message); +size_t sr__session_check_req__pack + (const Sr__SessionCheckReq *message, + uint8_t *out); +size_t sr__session_check_req__pack_to_buffer + (const Sr__SessionCheckReq *message, + ProtobufCBuffer *buffer); +Sr__SessionCheckReq * + sr__session_check_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_check_req__free_unpacked + (Sr__SessionCheckReq *message, + ProtobufCAllocator *allocator); +/* Sr__SessionCheckResp methods */ +void sr__session_check_resp__init + (Sr__SessionCheckResp *message); +size_t sr__session_check_resp__get_packed_size + (const Sr__SessionCheckResp *message); +size_t sr__session_check_resp__pack + (const Sr__SessionCheckResp *message, + uint8_t *out); +size_t sr__session_check_resp__pack_to_buffer + (const Sr__SessionCheckResp *message, + ProtobufCBuffer *buffer); +Sr__SessionCheckResp * + sr__session_check_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_check_resp__free_unpacked + (Sr__SessionCheckResp *message, + ProtobufCAllocator *allocator); +/* Sr__SessionSwitchDsReq methods */ +void sr__session_switch_ds_req__init + (Sr__SessionSwitchDsReq *message); +size_t sr__session_switch_ds_req__get_packed_size + (const Sr__SessionSwitchDsReq *message); +size_t sr__session_switch_ds_req__pack + (const Sr__SessionSwitchDsReq *message, + uint8_t *out); +size_t sr__session_switch_ds_req__pack_to_buffer + (const Sr__SessionSwitchDsReq *message, + ProtobufCBuffer *buffer); +Sr__SessionSwitchDsReq * + sr__session_switch_ds_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_switch_ds_req__free_unpacked + (Sr__SessionSwitchDsReq *message, + ProtobufCAllocator *allocator); +/* Sr__SessionSwitchDsResp methods */ +void sr__session_switch_ds_resp__init + (Sr__SessionSwitchDsResp *message); +size_t sr__session_switch_ds_resp__get_packed_size + (const Sr__SessionSwitchDsResp *message); +size_t sr__session_switch_ds_resp__pack + (const Sr__SessionSwitchDsResp *message, + uint8_t *out); +size_t sr__session_switch_ds_resp__pack_to_buffer + (const Sr__SessionSwitchDsResp *message, + ProtobufCBuffer *buffer); +Sr__SessionSwitchDsResp * + sr__session_switch_ds_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_switch_ds_resp__free_unpacked + (Sr__SessionSwitchDsResp *message, + ProtobufCAllocator *allocator); +/* Sr__SessionSetOptsReq methods */ +void sr__session_set_opts_req__init + (Sr__SessionSetOptsReq *message); +size_t sr__session_set_opts_req__get_packed_size + (const Sr__SessionSetOptsReq *message); +size_t sr__session_set_opts_req__pack + (const Sr__SessionSetOptsReq *message, + uint8_t *out); +size_t sr__session_set_opts_req__pack_to_buffer + (const Sr__SessionSetOptsReq *message, + ProtobufCBuffer *buffer); +Sr__SessionSetOptsReq * + sr__session_set_opts_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_set_opts_req__free_unpacked + (Sr__SessionSetOptsReq *message, + ProtobufCAllocator *allocator); +/* Sr__SessionSetOptsResp methods */ +void sr__session_set_opts_resp__init + (Sr__SessionSetOptsResp *message); +size_t sr__session_set_opts_resp__get_packed_size + (const Sr__SessionSetOptsResp *message); +size_t sr__session_set_opts_resp__pack + (const Sr__SessionSetOptsResp *message, + uint8_t *out); +size_t sr__session_set_opts_resp__pack_to_buffer + (const Sr__SessionSetOptsResp *message, + ProtobufCBuffer *buffer); +Sr__SessionSetOptsResp * + sr__session_set_opts_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__session_set_opts_resp__free_unpacked + (Sr__SessionSetOptsResp *message, + ProtobufCAllocator *allocator); +/* Sr__VersionVerifyReq methods */ +void sr__version_verify_req__init + (Sr__VersionVerifyReq *message); +size_t sr__version_verify_req__get_packed_size + (const Sr__VersionVerifyReq *message); +size_t sr__version_verify_req__pack + (const Sr__VersionVerifyReq *message, + uint8_t *out); +size_t sr__version_verify_req__pack_to_buffer + (const Sr__VersionVerifyReq *message, + ProtobufCBuffer *buffer); +Sr__VersionVerifyReq * + sr__version_verify_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__version_verify_req__free_unpacked + (Sr__VersionVerifyReq *message, + ProtobufCAllocator *allocator); +/* Sr__VersionVerifyResp methods */ +void sr__version_verify_resp__init + (Sr__VersionVerifyResp *message); +size_t sr__version_verify_resp__get_packed_size + (const Sr__VersionVerifyResp *message); +size_t sr__version_verify_resp__pack + (const Sr__VersionVerifyResp *message, + uint8_t *out); +size_t sr__version_verify_resp__pack_to_buffer + (const Sr__VersionVerifyResp *message, + ProtobufCBuffer *buffer); +Sr__VersionVerifyResp * + sr__version_verify_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__version_verify_resp__free_unpacked + (Sr__VersionVerifyResp *message, + ProtobufCAllocator *allocator); +/* Sr__SchemaRevision methods */ +void sr__schema_revision__init + (Sr__SchemaRevision *message); +size_t sr__schema_revision__get_packed_size + (const Sr__SchemaRevision *message); +size_t sr__schema_revision__pack + (const Sr__SchemaRevision *message, + uint8_t *out); +size_t sr__schema_revision__pack_to_buffer + (const Sr__SchemaRevision *message, + ProtobufCBuffer *buffer); +Sr__SchemaRevision * + sr__schema_revision__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__schema_revision__free_unpacked + (Sr__SchemaRevision *message, + ProtobufCAllocator *allocator); +/* Sr__SchemaSubmodule methods */ +void sr__schema_submodule__init + (Sr__SchemaSubmodule *message); +size_t sr__schema_submodule__get_packed_size + (const Sr__SchemaSubmodule *message); +size_t sr__schema_submodule__pack + (const Sr__SchemaSubmodule *message, + uint8_t *out); +size_t sr__schema_submodule__pack_to_buffer + (const Sr__SchemaSubmodule *message, + ProtobufCBuffer *buffer); +Sr__SchemaSubmodule * + sr__schema_submodule__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__schema_submodule__free_unpacked + (Sr__SchemaSubmodule *message, + ProtobufCAllocator *allocator); +/* Sr__Schema methods */ +void sr__schema__init + (Sr__Schema *message); +size_t sr__schema__get_packed_size + (const Sr__Schema *message); +size_t sr__schema__pack + (const Sr__Schema *message, + uint8_t *out); +size_t sr__schema__pack_to_buffer + (const Sr__Schema *message, + ProtobufCBuffer *buffer); +Sr__Schema * + sr__schema__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__schema__free_unpacked + (Sr__Schema *message, + ProtobufCAllocator *allocator); +/* Sr__ListSchemasReq methods */ +void sr__list_schemas_req__init + (Sr__ListSchemasReq *message); +size_t sr__list_schemas_req__get_packed_size + (const Sr__ListSchemasReq *message); +size_t sr__list_schemas_req__pack + (const Sr__ListSchemasReq *message, + uint8_t *out); +size_t sr__list_schemas_req__pack_to_buffer + (const Sr__ListSchemasReq *message, + ProtobufCBuffer *buffer); +Sr__ListSchemasReq * + sr__list_schemas_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__list_schemas_req__free_unpacked + (Sr__ListSchemasReq *message, + ProtobufCAllocator *allocator); +/* Sr__ListSchemasResp methods */ +void sr__list_schemas_resp__init + (Sr__ListSchemasResp *message); +size_t sr__list_schemas_resp__get_packed_size + (const Sr__ListSchemasResp *message); +size_t sr__list_schemas_resp__pack + (const Sr__ListSchemasResp *message, + uint8_t *out); +size_t sr__list_schemas_resp__pack_to_buffer + (const Sr__ListSchemasResp *message, + ProtobufCBuffer *buffer); +Sr__ListSchemasResp * + sr__list_schemas_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__list_schemas_resp__free_unpacked + (Sr__ListSchemasResp *message, + ProtobufCAllocator *allocator); +/* Sr__GetSchemaReq methods */ +void sr__get_schema_req__init + (Sr__GetSchemaReq *message); +size_t sr__get_schema_req__get_packed_size + (const Sr__GetSchemaReq *message); +size_t sr__get_schema_req__pack + (const Sr__GetSchemaReq *message, + uint8_t *out); +size_t sr__get_schema_req__pack_to_buffer + (const Sr__GetSchemaReq *message, + ProtobufCBuffer *buffer); +Sr__GetSchemaReq * + sr__get_schema_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_schema_req__free_unpacked + (Sr__GetSchemaReq *message, + ProtobufCAllocator *allocator); +/* Sr__GetSchemaResp methods */ +void sr__get_schema_resp__init + (Sr__GetSchemaResp *message); +size_t sr__get_schema_resp__get_packed_size + (const Sr__GetSchemaResp *message); +size_t sr__get_schema_resp__pack + (const Sr__GetSchemaResp *message, + uint8_t *out); +size_t sr__get_schema_resp__pack_to_buffer + (const Sr__GetSchemaResp *message, + ProtobufCBuffer *buffer); +Sr__GetSchemaResp * + sr__get_schema_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_schema_resp__free_unpacked + (Sr__GetSchemaResp *message, + ProtobufCAllocator *allocator); +/* Sr__GetItemReq methods */ +void sr__get_item_req__init + (Sr__GetItemReq *message); +size_t sr__get_item_req__get_packed_size + (const Sr__GetItemReq *message); +size_t sr__get_item_req__pack + (const Sr__GetItemReq *message, + uint8_t *out); +size_t sr__get_item_req__pack_to_buffer + (const Sr__GetItemReq *message, + ProtobufCBuffer *buffer); +Sr__GetItemReq * + sr__get_item_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_item_req__free_unpacked + (Sr__GetItemReq *message, + ProtobufCAllocator *allocator); +/* Sr__GetItemResp methods */ +void sr__get_item_resp__init + (Sr__GetItemResp *message); +size_t sr__get_item_resp__get_packed_size + (const Sr__GetItemResp *message); +size_t sr__get_item_resp__pack + (const Sr__GetItemResp *message, + uint8_t *out); +size_t sr__get_item_resp__pack_to_buffer + (const Sr__GetItemResp *message, + ProtobufCBuffer *buffer); +Sr__GetItemResp * + sr__get_item_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_item_resp__free_unpacked + (Sr__GetItemResp *message, + ProtobufCAllocator *allocator); +/* Sr__GetItemsReq methods */ +void sr__get_items_req__init + (Sr__GetItemsReq *message); +size_t sr__get_items_req__get_packed_size + (const Sr__GetItemsReq *message); +size_t sr__get_items_req__pack + (const Sr__GetItemsReq *message, + uint8_t *out); +size_t sr__get_items_req__pack_to_buffer + (const Sr__GetItemsReq *message, + ProtobufCBuffer *buffer); +Sr__GetItemsReq * + sr__get_items_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_items_req__free_unpacked + (Sr__GetItemsReq *message, + ProtobufCAllocator *allocator); +/* Sr__GetItemsResp methods */ +void sr__get_items_resp__init + (Sr__GetItemsResp *message); +size_t sr__get_items_resp__get_packed_size + (const Sr__GetItemsResp *message); +size_t sr__get_items_resp__pack + (const Sr__GetItemsResp *message, + uint8_t *out); +size_t sr__get_items_resp__pack_to_buffer + (const Sr__GetItemsResp *message, + ProtobufCBuffer *buffer); +Sr__GetItemsResp * + sr__get_items_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_items_resp__free_unpacked + (Sr__GetItemsResp *message, + ProtobufCAllocator *allocator); +/* Sr__GetSubtreeReq methods */ +void sr__get_subtree_req__init + (Sr__GetSubtreeReq *message); +size_t sr__get_subtree_req__get_packed_size + (const Sr__GetSubtreeReq *message); +size_t sr__get_subtree_req__pack + (const Sr__GetSubtreeReq *message, + uint8_t *out); +size_t sr__get_subtree_req__pack_to_buffer + (const Sr__GetSubtreeReq *message, + ProtobufCBuffer *buffer); +Sr__GetSubtreeReq * + sr__get_subtree_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_subtree_req__free_unpacked + (Sr__GetSubtreeReq *message, + ProtobufCAllocator *allocator); +/* Sr__GetSubtreeResp methods */ +void sr__get_subtree_resp__init + (Sr__GetSubtreeResp *message); +size_t sr__get_subtree_resp__get_packed_size + (const Sr__GetSubtreeResp *message); +size_t sr__get_subtree_resp__pack + (const Sr__GetSubtreeResp *message, + uint8_t *out); +size_t sr__get_subtree_resp__pack_to_buffer + (const Sr__GetSubtreeResp *message, + ProtobufCBuffer *buffer); +Sr__GetSubtreeResp * + sr__get_subtree_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_subtree_resp__free_unpacked + (Sr__GetSubtreeResp *message, + ProtobufCAllocator *allocator); +/* Sr__GetSubtreesReq methods */ +void sr__get_subtrees_req__init + (Sr__GetSubtreesReq *message); +size_t sr__get_subtrees_req__get_packed_size + (const Sr__GetSubtreesReq *message); +size_t sr__get_subtrees_req__pack + (const Sr__GetSubtreesReq *message, + uint8_t *out); +size_t sr__get_subtrees_req__pack_to_buffer + (const Sr__GetSubtreesReq *message, + ProtobufCBuffer *buffer); +Sr__GetSubtreesReq * + sr__get_subtrees_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_subtrees_req__free_unpacked + (Sr__GetSubtreesReq *message, + ProtobufCAllocator *allocator); +/* Sr__GetSubtreesResp methods */ +void sr__get_subtrees_resp__init + (Sr__GetSubtreesResp *message); +size_t sr__get_subtrees_resp__get_packed_size + (const Sr__GetSubtreesResp *message); +size_t sr__get_subtrees_resp__pack + (const Sr__GetSubtreesResp *message, + uint8_t *out); +size_t sr__get_subtrees_resp__pack_to_buffer + (const Sr__GetSubtreesResp *message, + ProtobufCBuffer *buffer); +Sr__GetSubtreesResp * + sr__get_subtrees_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_subtrees_resp__free_unpacked + (Sr__GetSubtreesResp *message, + ProtobufCAllocator *allocator); +/* Sr__GetSubtreeChunkReq methods */ +void sr__get_subtree_chunk_req__init + (Sr__GetSubtreeChunkReq *message); +size_t sr__get_subtree_chunk_req__get_packed_size + (const Sr__GetSubtreeChunkReq *message); +size_t sr__get_subtree_chunk_req__pack + (const Sr__GetSubtreeChunkReq *message, + uint8_t *out); +size_t sr__get_subtree_chunk_req__pack_to_buffer + (const Sr__GetSubtreeChunkReq *message, + ProtobufCBuffer *buffer); +Sr__GetSubtreeChunkReq * + sr__get_subtree_chunk_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_subtree_chunk_req__free_unpacked + (Sr__GetSubtreeChunkReq *message, + ProtobufCAllocator *allocator); +/* Sr__GetSubtreeChunkResp methods */ +void sr__get_subtree_chunk_resp__init + (Sr__GetSubtreeChunkResp *message); +size_t sr__get_subtree_chunk_resp__get_packed_size + (const Sr__GetSubtreeChunkResp *message); +size_t sr__get_subtree_chunk_resp__pack + (const Sr__GetSubtreeChunkResp *message, + uint8_t *out); +size_t sr__get_subtree_chunk_resp__pack_to_buffer + (const Sr__GetSubtreeChunkResp *message, + ProtobufCBuffer *buffer); +Sr__GetSubtreeChunkResp * + sr__get_subtree_chunk_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_subtree_chunk_resp__free_unpacked + (Sr__GetSubtreeChunkResp *message, + ProtobufCAllocator *allocator); +/* Sr__SetItemReq methods */ +void sr__set_item_req__init + (Sr__SetItemReq *message); +size_t sr__set_item_req__get_packed_size + (const Sr__SetItemReq *message); +size_t sr__set_item_req__pack + (const Sr__SetItemReq *message, + uint8_t *out); +size_t sr__set_item_req__pack_to_buffer + (const Sr__SetItemReq *message, + ProtobufCBuffer *buffer); +Sr__SetItemReq * + sr__set_item_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__set_item_req__free_unpacked + (Sr__SetItemReq *message, + ProtobufCAllocator *allocator); +/* Sr__SetItemResp methods */ +void sr__set_item_resp__init + (Sr__SetItemResp *message); +size_t sr__set_item_resp__get_packed_size + (const Sr__SetItemResp *message); +size_t sr__set_item_resp__pack + (const Sr__SetItemResp *message, + uint8_t *out); +size_t sr__set_item_resp__pack_to_buffer + (const Sr__SetItemResp *message, + ProtobufCBuffer *buffer); +Sr__SetItemResp * + sr__set_item_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__set_item_resp__free_unpacked + (Sr__SetItemResp *message, + ProtobufCAllocator *allocator); +/* Sr__SetItemStrReq methods */ +void sr__set_item_str_req__init + (Sr__SetItemStrReq *message); +size_t sr__set_item_str_req__get_packed_size + (const Sr__SetItemStrReq *message); +size_t sr__set_item_str_req__pack + (const Sr__SetItemStrReq *message, + uint8_t *out); +size_t sr__set_item_str_req__pack_to_buffer + (const Sr__SetItemStrReq *message, + ProtobufCBuffer *buffer); +Sr__SetItemStrReq * + sr__set_item_str_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__set_item_str_req__free_unpacked + (Sr__SetItemStrReq *message, + ProtobufCAllocator *allocator); +/* Sr__SetItemStrResp methods */ +void sr__set_item_str_resp__init + (Sr__SetItemStrResp *message); +size_t sr__set_item_str_resp__get_packed_size + (const Sr__SetItemStrResp *message); +size_t sr__set_item_str_resp__pack + (const Sr__SetItemStrResp *message, + uint8_t *out); +size_t sr__set_item_str_resp__pack_to_buffer + (const Sr__SetItemStrResp *message, + ProtobufCBuffer *buffer); +Sr__SetItemStrResp * + sr__set_item_str_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__set_item_str_resp__free_unpacked + (Sr__SetItemStrResp *message, + ProtobufCAllocator *allocator); +/* Sr__DeleteItemReq methods */ +void sr__delete_item_req__init + (Sr__DeleteItemReq *message); +size_t sr__delete_item_req__get_packed_size + (const Sr__DeleteItemReq *message); +size_t sr__delete_item_req__pack + (const Sr__DeleteItemReq *message, + uint8_t *out); +size_t sr__delete_item_req__pack_to_buffer + (const Sr__DeleteItemReq *message, + ProtobufCBuffer *buffer); +Sr__DeleteItemReq * + sr__delete_item_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__delete_item_req__free_unpacked + (Sr__DeleteItemReq *message, + ProtobufCAllocator *allocator); +/* Sr__DeleteItemResp methods */ +void sr__delete_item_resp__init + (Sr__DeleteItemResp *message); +size_t sr__delete_item_resp__get_packed_size + (const Sr__DeleteItemResp *message); +size_t sr__delete_item_resp__pack + (const Sr__DeleteItemResp *message, + uint8_t *out); +size_t sr__delete_item_resp__pack_to_buffer + (const Sr__DeleteItemResp *message, + ProtobufCBuffer *buffer); +Sr__DeleteItemResp * + sr__delete_item_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__delete_item_resp__free_unpacked + (Sr__DeleteItemResp *message, + ProtobufCAllocator *allocator); +/* Sr__MoveItemReq methods */ +void sr__move_item_req__init + (Sr__MoveItemReq *message); +size_t sr__move_item_req__get_packed_size + (const Sr__MoveItemReq *message); +size_t sr__move_item_req__pack + (const Sr__MoveItemReq *message, + uint8_t *out); +size_t sr__move_item_req__pack_to_buffer + (const Sr__MoveItemReq *message, + ProtobufCBuffer *buffer); +Sr__MoveItemReq * + sr__move_item_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__move_item_req__free_unpacked + (Sr__MoveItemReq *message, + ProtobufCAllocator *allocator); +/* Sr__MoveItemResp methods */ +void sr__move_item_resp__init + (Sr__MoveItemResp *message); +size_t sr__move_item_resp__get_packed_size + (const Sr__MoveItemResp *message); +size_t sr__move_item_resp__pack + (const Sr__MoveItemResp *message, + uint8_t *out); +size_t sr__move_item_resp__pack_to_buffer + (const Sr__MoveItemResp *message, + ProtobufCBuffer *buffer); +Sr__MoveItemResp * + sr__move_item_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__move_item_resp__free_unpacked + (Sr__MoveItemResp *message, + ProtobufCAllocator *allocator); +/* Sr__ValidateReq methods */ +void sr__validate_req__init + (Sr__ValidateReq *message); +size_t sr__validate_req__get_packed_size + (const Sr__ValidateReq *message); +size_t sr__validate_req__pack + (const Sr__ValidateReq *message, + uint8_t *out); +size_t sr__validate_req__pack_to_buffer + (const Sr__ValidateReq *message, + ProtobufCBuffer *buffer); +Sr__ValidateReq * + sr__validate_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__validate_req__free_unpacked + (Sr__ValidateReq *message, + ProtobufCAllocator *allocator); +/* Sr__ValidateResp methods */ +void sr__validate_resp__init + (Sr__ValidateResp *message); +size_t sr__validate_resp__get_packed_size + (const Sr__ValidateResp *message); +size_t sr__validate_resp__pack + (const Sr__ValidateResp *message, + uint8_t *out); +size_t sr__validate_resp__pack_to_buffer + (const Sr__ValidateResp *message, + ProtobufCBuffer *buffer); +Sr__ValidateResp * + sr__validate_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__validate_resp__free_unpacked + (Sr__ValidateResp *message, + ProtobufCAllocator *allocator); +/* Sr__CommitReq methods */ +void sr__commit_req__init + (Sr__CommitReq *message); +size_t sr__commit_req__get_packed_size + (const Sr__CommitReq *message); +size_t sr__commit_req__pack + (const Sr__CommitReq *message, + uint8_t *out); +size_t sr__commit_req__pack_to_buffer + (const Sr__CommitReq *message, + ProtobufCBuffer *buffer); +Sr__CommitReq * + sr__commit_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__commit_req__free_unpacked + (Sr__CommitReq *message, + ProtobufCAllocator *allocator); +/* Sr__CommitResp methods */ +void sr__commit_resp__init + (Sr__CommitResp *message); +size_t sr__commit_resp__get_packed_size + (const Sr__CommitResp *message); +size_t sr__commit_resp__pack + (const Sr__CommitResp *message, + uint8_t *out); +size_t sr__commit_resp__pack_to_buffer + (const Sr__CommitResp *message, + ProtobufCBuffer *buffer); +Sr__CommitResp * + sr__commit_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__commit_resp__free_unpacked + (Sr__CommitResp *message, + ProtobufCAllocator *allocator); +/* Sr__DiscardChangesReq methods */ +void sr__discard_changes_req__init + (Sr__DiscardChangesReq *message); +size_t sr__discard_changes_req__get_packed_size + (const Sr__DiscardChangesReq *message); +size_t sr__discard_changes_req__pack + (const Sr__DiscardChangesReq *message, + uint8_t *out); +size_t sr__discard_changes_req__pack_to_buffer + (const Sr__DiscardChangesReq *message, + ProtobufCBuffer *buffer); +Sr__DiscardChangesReq * + sr__discard_changes_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__discard_changes_req__free_unpacked + (Sr__DiscardChangesReq *message, + ProtobufCAllocator *allocator); +/* Sr__DiscardChangesResp methods */ +void sr__discard_changes_resp__init + (Sr__DiscardChangesResp *message); +size_t sr__discard_changes_resp__get_packed_size + (const Sr__DiscardChangesResp *message); +size_t sr__discard_changes_resp__pack + (const Sr__DiscardChangesResp *message, + uint8_t *out); +size_t sr__discard_changes_resp__pack_to_buffer + (const Sr__DiscardChangesResp *message, + ProtobufCBuffer *buffer); +Sr__DiscardChangesResp * + sr__discard_changes_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__discard_changes_resp__free_unpacked + (Sr__DiscardChangesResp *message, + ProtobufCAllocator *allocator); +/* Sr__CopyConfigReq methods */ +void sr__copy_config_req__init + (Sr__CopyConfigReq *message); +size_t sr__copy_config_req__get_packed_size + (const Sr__CopyConfigReq *message); +size_t sr__copy_config_req__pack + (const Sr__CopyConfigReq *message, + uint8_t *out); +size_t sr__copy_config_req__pack_to_buffer + (const Sr__CopyConfigReq *message, + ProtobufCBuffer *buffer); +Sr__CopyConfigReq * + sr__copy_config_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__copy_config_req__free_unpacked + (Sr__CopyConfigReq *message, + ProtobufCAllocator *allocator); +/* Sr__CopyConfigResp methods */ +void sr__copy_config_resp__init + (Sr__CopyConfigResp *message); +size_t sr__copy_config_resp__get_packed_size + (const Sr__CopyConfigResp *message); +size_t sr__copy_config_resp__pack + (const Sr__CopyConfigResp *message, + uint8_t *out); +size_t sr__copy_config_resp__pack_to_buffer + (const Sr__CopyConfigResp *message, + ProtobufCBuffer *buffer); +Sr__CopyConfigResp * + sr__copy_config_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__copy_config_resp__free_unpacked + (Sr__CopyConfigResp *message, + ProtobufCAllocator *allocator); +/* Sr__LockReq methods */ +void sr__lock_req__init + (Sr__LockReq *message); +size_t sr__lock_req__get_packed_size + (const Sr__LockReq *message); +size_t sr__lock_req__pack + (const Sr__LockReq *message, + uint8_t *out); +size_t sr__lock_req__pack_to_buffer + (const Sr__LockReq *message, + ProtobufCBuffer *buffer); +Sr__LockReq * + sr__lock_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__lock_req__free_unpacked + (Sr__LockReq *message, + ProtobufCAllocator *allocator); +/* Sr__LockResp methods */ +void sr__lock_resp__init + (Sr__LockResp *message); +size_t sr__lock_resp__get_packed_size + (const Sr__LockResp *message); +size_t sr__lock_resp__pack + (const Sr__LockResp *message, + uint8_t *out); +size_t sr__lock_resp__pack_to_buffer + (const Sr__LockResp *message, + ProtobufCBuffer *buffer); +Sr__LockResp * + sr__lock_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__lock_resp__free_unpacked + (Sr__LockResp *message, + ProtobufCAllocator *allocator); +/* Sr__UnlockReq methods */ +void sr__unlock_req__init + (Sr__UnlockReq *message); +size_t sr__unlock_req__get_packed_size + (const Sr__UnlockReq *message); +size_t sr__unlock_req__pack + (const Sr__UnlockReq *message, + uint8_t *out); +size_t sr__unlock_req__pack_to_buffer + (const Sr__UnlockReq *message, + ProtobufCBuffer *buffer); +Sr__UnlockReq * + sr__unlock_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__unlock_req__free_unpacked + (Sr__UnlockReq *message, + ProtobufCAllocator *allocator); +/* Sr__UnlockResp methods */ +void sr__unlock_resp__init + (Sr__UnlockResp *message); +size_t sr__unlock_resp__get_packed_size + (const Sr__UnlockResp *message); +size_t sr__unlock_resp__pack + (const Sr__UnlockResp *message, + uint8_t *out); +size_t sr__unlock_resp__pack_to_buffer + (const Sr__UnlockResp *message, + ProtobufCBuffer *buffer); +Sr__UnlockResp * + sr__unlock_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__unlock_resp__free_unpacked + (Sr__UnlockResp *message, + ProtobufCAllocator *allocator); +/* Sr__SubscribeReq methods */ +void sr__subscribe_req__init + (Sr__SubscribeReq *message); +size_t sr__subscribe_req__get_packed_size + (const Sr__SubscribeReq *message); +size_t sr__subscribe_req__pack + (const Sr__SubscribeReq *message, + uint8_t *out); +size_t sr__subscribe_req__pack_to_buffer + (const Sr__SubscribeReq *message, + ProtobufCBuffer *buffer); +Sr__SubscribeReq * + sr__subscribe_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__subscribe_req__free_unpacked + (Sr__SubscribeReq *message, + ProtobufCAllocator *allocator); +/* Sr__SubscribeResp methods */ +void sr__subscribe_resp__init + (Sr__SubscribeResp *message); +size_t sr__subscribe_resp__get_packed_size + (const Sr__SubscribeResp *message); +size_t sr__subscribe_resp__pack + (const Sr__SubscribeResp *message, + uint8_t *out); +size_t sr__subscribe_resp__pack_to_buffer + (const Sr__SubscribeResp *message, + ProtobufCBuffer *buffer); +Sr__SubscribeResp * + sr__subscribe_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__subscribe_resp__free_unpacked + (Sr__SubscribeResp *message, + ProtobufCAllocator *allocator); +/* Sr__UnsubscribeReq methods */ +void sr__unsubscribe_req__init + (Sr__UnsubscribeReq *message); +size_t sr__unsubscribe_req__get_packed_size + (const Sr__UnsubscribeReq *message); +size_t sr__unsubscribe_req__pack + (const Sr__UnsubscribeReq *message, + uint8_t *out); +size_t sr__unsubscribe_req__pack_to_buffer + (const Sr__UnsubscribeReq *message, + ProtobufCBuffer *buffer); +Sr__UnsubscribeReq * + sr__unsubscribe_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__unsubscribe_req__free_unpacked + (Sr__UnsubscribeReq *message, + ProtobufCAllocator *allocator); +/* Sr__UnsubscribeResp methods */ +void sr__unsubscribe_resp__init + (Sr__UnsubscribeResp *message); +size_t sr__unsubscribe_resp__get_packed_size + (const Sr__UnsubscribeResp *message); +size_t sr__unsubscribe_resp__pack + (const Sr__UnsubscribeResp *message, + uint8_t *out); +size_t sr__unsubscribe_resp__pack_to_buffer + (const Sr__UnsubscribeResp *message, + ProtobufCBuffer *buffer); +Sr__UnsubscribeResp * + sr__unsubscribe_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__unsubscribe_resp__free_unpacked + (Sr__UnsubscribeResp *message, + ProtobufCAllocator *allocator); +/* Sr__CheckEnabledRunningReq methods */ +void sr__check_enabled_running_req__init + (Sr__CheckEnabledRunningReq *message); +size_t sr__check_enabled_running_req__get_packed_size + (const Sr__CheckEnabledRunningReq *message); +size_t sr__check_enabled_running_req__pack + (const Sr__CheckEnabledRunningReq *message, + uint8_t *out); +size_t sr__check_enabled_running_req__pack_to_buffer + (const Sr__CheckEnabledRunningReq *message, + ProtobufCBuffer *buffer); +Sr__CheckEnabledRunningReq * + sr__check_enabled_running_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__check_enabled_running_req__free_unpacked + (Sr__CheckEnabledRunningReq *message, + ProtobufCAllocator *allocator); +/* Sr__CheckEnabledRunningResp methods */ +void sr__check_enabled_running_resp__init + (Sr__CheckEnabledRunningResp *message); +size_t sr__check_enabled_running_resp__get_packed_size + (const Sr__CheckEnabledRunningResp *message); +size_t sr__check_enabled_running_resp__pack + (const Sr__CheckEnabledRunningResp *message, + uint8_t *out); +size_t sr__check_enabled_running_resp__pack_to_buffer + (const Sr__CheckEnabledRunningResp *message, + ProtobufCBuffer *buffer); +Sr__CheckEnabledRunningResp * + sr__check_enabled_running_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__check_enabled_running_resp__free_unpacked + (Sr__CheckEnabledRunningResp *message, + ProtobufCAllocator *allocator); +/* Sr__ModuleInstallNotification methods */ +void sr__module_install_notification__init + (Sr__ModuleInstallNotification *message); +size_t sr__module_install_notification__get_packed_size + (const Sr__ModuleInstallNotification *message); +size_t sr__module_install_notification__pack + (const Sr__ModuleInstallNotification *message, + uint8_t *out); +size_t sr__module_install_notification__pack_to_buffer + (const Sr__ModuleInstallNotification *message, + ProtobufCBuffer *buffer); +Sr__ModuleInstallNotification * + sr__module_install_notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__module_install_notification__free_unpacked + (Sr__ModuleInstallNotification *message, + ProtobufCAllocator *allocator); +/* Sr__FeatureEnableNotification methods */ +void sr__feature_enable_notification__init + (Sr__FeatureEnableNotification *message); +size_t sr__feature_enable_notification__get_packed_size + (const Sr__FeatureEnableNotification *message); +size_t sr__feature_enable_notification__pack + (const Sr__FeatureEnableNotification *message, + uint8_t *out); +size_t sr__feature_enable_notification__pack_to_buffer + (const Sr__FeatureEnableNotification *message, + ProtobufCBuffer *buffer); +Sr__FeatureEnableNotification * + sr__feature_enable_notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__feature_enable_notification__free_unpacked + (Sr__FeatureEnableNotification *message, + ProtobufCAllocator *allocator); +/* Sr__ModuleChangeNotification methods */ +void sr__module_change_notification__init + (Sr__ModuleChangeNotification *message); +size_t sr__module_change_notification__get_packed_size + (const Sr__ModuleChangeNotification *message); +size_t sr__module_change_notification__pack + (const Sr__ModuleChangeNotification *message, + uint8_t *out); +size_t sr__module_change_notification__pack_to_buffer + (const Sr__ModuleChangeNotification *message, + ProtobufCBuffer *buffer); +Sr__ModuleChangeNotification * + sr__module_change_notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__module_change_notification__free_unpacked + (Sr__ModuleChangeNotification *message, + ProtobufCAllocator *allocator); +/* Sr__SubtreeChangeNotification methods */ +void sr__subtree_change_notification__init + (Sr__SubtreeChangeNotification *message); +size_t sr__subtree_change_notification__get_packed_size + (const Sr__SubtreeChangeNotification *message); +size_t sr__subtree_change_notification__pack + (const Sr__SubtreeChangeNotification *message, + uint8_t *out); +size_t sr__subtree_change_notification__pack_to_buffer + (const Sr__SubtreeChangeNotification *message, + ProtobufCBuffer *buffer); +Sr__SubtreeChangeNotification * + sr__subtree_change_notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__subtree_change_notification__free_unpacked + (Sr__SubtreeChangeNotification *message, + ProtobufCAllocator *allocator); +/* Sr__Change methods */ +void sr__change__init + (Sr__Change *message); +size_t sr__change__get_packed_size + (const Sr__Change *message); +size_t sr__change__pack + (const Sr__Change *message, + uint8_t *out); +size_t sr__change__pack_to_buffer + (const Sr__Change *message, + ProtobufCBuffer *buffer); +Sr__Change * + sr__change__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__change__free_unpacked + (Sr__Change *message, + ProtobufCAllocator *allocator); +/* Sr__GetChangesReq methods */ +void sr__get_changes_req__init + (Sr__GetChangesReq *message); +size_t sr__get_changes_req__get_packed_size + (const Sr__GetChangesReq *message); +size_t sr__get_changes_req__pack + (const Sr__GetChangesReq *message, + uint8_t *out); +size_t sr__get_changes_req__pack_to_buffer + (const Sr__GetChangesReq *message, + ProtobufCBuffer *buffer); +Sr__GetChangesReq * + sr__get_changes_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_changes_req__free_unpacked + (Sr__GetChangesReq *message, + ProtobufCAllocator *allocator); +/* Sr__GetChangesResp methods */ +void sr__get_changes_resp__init + (Sr__GetChangesResp *message); +size_t sr__get_changes_resp__get_packed_size + (const Sr__GetChangesResp *message); +size_t sr__get_changes_resp__pack + (const Sr__GetChangesResp *message, + uint8_t *out); +size_t sr__get_changes_resp__pack_to_buffer + (const Sr__GetChangesResp *message, + ProtobufCBuffer *buffer); +Sr__GetChangesResp * + sr__get_changes_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__get_changes_resp__free_unpacked + (Sr__GetChangesResp *message, + ProtobufCAllocator *allocator); +/* Sr__CheckExecPermReq methods */ +void sr__check_exec_perm_req__init + (Sr__CheckExecPermReq *message); +size_t sr__check_exec_perm_req__get_packed_size + (const Sr__CheckExecPermReq *message); +size_t sr__check_exec_perm_req__pack + (const Sr__CheckExecPermReq *message, + uint8_t *out); +size_t sr__check_exec_perm_req__pack_to_buffer + (const Sr__CheckExecPermReq *message, + ProtobufCBuffer *buffer); +Sr__CheckExecPermReq * + sr__check_exec_perm_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__check_exec_perm_req__free_unpacked + (Sr__CheckExecPermReq *message, + ProtobufCAllocator *allocator); +/* Sr__CheckExecPermResp methods */ +void sr__check_exec_perm_resp__init + (Sr__CheckExecPermResp *message); +size_t sr__check_exec_perm_resp__get_packed_size + (const Sr__CheckExecPermResp *message); +size_t sr__check_exec_perm_resp__pack + (const Sr__CheckExecPermResp *message, + uint8_t *out); +size_t sr__check_exec_perm_resp__pack_to_buffer + (const Sr__CheckExecPermResp *message, + ProtobufCBuffer *buffer); +Sr__CheckExecPermResp * + sr__check_exec_perm_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__check_exec_perm_resp__free_unpacked + (Sr__CheckExecPermResp *message, + ProtobufCAllocator *allocator); +/* Sr__RPCReq methods */ +void sr__rpcreq__init + (Sr__RPCReq *message); +size_t sr__rpcreq__get_packed_size + (const Sr__RPCReq *message); +size_t sr__rpcreq__pack + (const Sr__RPCReq *message, + uint8_t *out); +size_t sr__rpcreq__pack_to_buffer + (const Sr__RPCReq *message, + ProtobufCBuffer *buffer); +Sr__RPCReq * + sr__rpcreq__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__rpcreq__free_unpacked + (Sr__RPCReq *message, + ProtobufCAllocator *allocator); +/* Sr__RPCResp methods */ +void sr__rpcresp__init + (Sr__RPCResp *message); +size_t sr__rpcresp__get_packed_size + (const Sr__RPCResp *message); +size_t sr__rpcresp__pack + (const Sr__RPCResp *message, + uint8_t *out); +size_t sr__rpcresp__pack_to_buffer + (const Sr__RPCResp *message, + ProtobufCBuffer *buffer); +Sr__RPCResp * + sr__rpcresp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__rpcresp__free_unpacked + (Sr__RPCResp *message, + ProtobufCAllocator *allocator); +/* Sr__EventNotifReq methods */ +void sr__event_notif_req__init + (Sr__EventNotifReq *message); +size_t sr__event_notif_req__get_packed_size + (const Sr__EventNotifReq *message); +size_t sr__event_notif_req__pack + (const Sr__EventNotifReq *message, + uint8_t *out); +size_t sr__event_notif_req__pack_to_buffer + (const Sr__EventNotifReq *message, + ProtobufCBuffer *buffer); +Sr__EventNotifReq * + sr__event_notif_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__event_notif_req__free_unpacked + (Sr__EventNotifReq *message, + ProtobufCAllocator *allocator); +/* Sr__EventNotifResp methods */ +void sr__event_notif_resp__init + (Sr__EventNotifResp *message); +size_t sr__event_notif_resp__get_packed_size + (const Sr__EventNotifResp *message); +size_t sr__event_notif_resp__pack + (const Sr__EventNotifResp *message, + uint8_t *out); +size_t sr__event_notif_resp__pack_to_buffer + (const Sr__EventNotifResp *message, + ProtobufCBuffer *buffer); +Sr__EventNotifResp * + sr__event_notif_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__event_notif_resp__free_unpacked + (Sr__EventNotifResp *message, + ProtobufCAllocator *allocator); +/* Sr__EventNotifReplayReq methods */ +void sr__event_notif_replay_req__init + (Sr__EventNotifReplayReq *message); +size_t sr__event_notif_replay_req__get_packed_size + (const Sr__EventNotifReplayReq *message); +size_t sr__event_notif_replay_req__pack + (const Sr__EventNotifReplayReq *message, + uint8_t *out); +size_t sr__event_notif_replay_req__pack_to_buffer + (const Sr__EventNotifReplayReq *message, + ProtobufCBuffer *buffer); +Sr__EventNotifReplayReq * + sr__event_notif_replay_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__event_notif_replay_req__free_unpacked + (Sr__EventNotifReplayReq *message, + ProtobufCAllocator *allocator); +/* Sr__EventNotifReplayResp methods */ +void sr__event_notif_replay_resp__init + (Sr__EventNotifReplayResp *message); +size_t sr__event_notif_replay_resp__get_packed_size + (const Sr__EventNotifReplayResp *message); +size_t sr__event_notif_replay_resp__pack + (const Sr__EventNotifReplayResp *message, + uint8_t *out); +size_t sr__event_notif_replay_resp__pack_to_buffer + (const Sr__EventNotifReplayResp *message, + ProtobufCBuffer *buffer); +Sr__EventNotifReplayResp * + sr__event_notif_replay_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__event_notif_replay_resp__free_unpacked + (Sr__EventNotifReplayResp *message, + ProtobufCAllocator *allocator); +/* Sr__DataProvideReq methods */ +void sr__data_provide_req__init + (Sr__DataProvideReq *message); +size_t sr__data_provide_req__get_packed_size + (const Sr__DataProvideReq *message); +size_t sr__data_provide_req__pack + (const Sr__DataProvideReq *message, + uint8_t *out); +size_t sr__data_provide_req__pack_to_buffer + (const Sr__DataProvideReq *message, + ProtobufCBuffer *buffer); +Sr__DataProvideReq * + sr__data_provide_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__data_provide_req__free_unpacked + (Sr__DataProvideReq *message, + ProtobufCAllocator *allocator); +/* Sr__DataProvideResp methods */ +void sr__data_provide_resp__init + (Sr__DataProvideResp *message); +size_t sr__data_provide_resp__get_packed_size + (const Sr__DataProvideResp *message); +size_t sr__data_provide_resp__pack + (const Sr__DataProvideResp *message, + uint8_t *out); +size_t sr__data_provide_resp__pack_to_buffer + (const Sr__DataProvideResp *message, + ProtobufCBuffer *buffer); +Sr__DataProvideResp * + sr__data_provide_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__data_provide_resp__free_unpacked + (Sr__DataProvideResp *message, + ProtobufCAllocator *allocator); +/* Sr__ModuleInstallReq methods */ +void sr__module_install_req__init + (Sr__ModuleInstallReq *message); +size_t sr__module_install_req__get_packed_size + (const Sr__ModuleInstallReq *message); +size_t sr__module_install_req__pack + (const Sr__ModuleInstallReq *message, + uint8_t *out); +size_t sr__module_install_req__pack_to_buffer + (const Sr__ModuleInstallReq *message, + ProtobufCBuffer *buffer); +Sr__ModuleInstallReq * + sr__module_install_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__module_install_req__free_unpacked + (Sr__ModuleInstallReq *message, + ProtobufCAllocator *allocator); +/* Sr__ModuleInstallResp methods */ +void sr__module_install_resp__init + (Sr__ModuleInstallResp *message); +size_t sr__module_install_resp__get_packed_size + (const Sr__ModuleInstallResp *message); +size_t sr__module_install_resp__pack + (const Sr__ModuleInstallResp *message, + uint8_t *out); +size_t sr__module_install_resp__pack_to_buffer + (const Sr__ModuleInstallResp *message, + ProtobufCBuffer *buffer); +Sr__ModuleInstallResp * + sr__module_install_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__module_install_resp__free_unpacked + (Sr__ModuleInstallResp *message, + ProtobufCAllocator *allocator); +/* Sr__FeatureEnableReq methods */ +void sr__feature_enable_req__init + (Sr__FeatureEnableReq *message); +size_t sr__feature_enable_req__get_packed_size + (const Sr__FeatureEnableReq *message); +size_t sr__feature_enable_req__pack + (const Sr__FeatureEnableReq *message, + uint8_t *out); +size_t sr__feature_enable_req__pack_to_buffer + (const Sr__FeatureEnableReq *message, + ProtobufCBuffer *buffer); +Sr__FeatureEnableReq * + sr__feature_enable_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__feature_enable_req__free_unpacked + (Sr__FeatureEnableReq *message, + ProtobufCAllocator *allocator); +/* Sr__FeatureEnableResp methods */ +void sr__feature_enable_resp__init + (Sr__FeatureEnableResp *message); +size_t sr__feature_enable_resp__get_packed_size + (const Sr__FeatureEnableResp *message); +size_t sr__feature_enable_resp__pack + (const Sr__FeatureEnableResp *message, + uint8_t *out); +size_t sr__feature_enable_resp__pack_to_buffer + (const Sr__FeatureEnableResp *message, + ProtobufCBuffer *buffer); +Sr__FeatureEnableResp * + sr__feature_enable_resp__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__feature_enable_resp__free_unpacked + (Sr__FeatureEnableResp *message, + ProtobufCAllocator *allocator); +/* Sr__UnsubscribeDestinationReq methods */ +void sr__unsubscribe_destination_req__init + (Sr__UnsubscribeDestinationReq *message); +size_t sr__unsubscribe_destination_req__get_packed_size + (const Sr__UnsubscribeDestinationReq *message); +size_t sr__unsubscribe_destination_req__pack + (const Sr__UnsubscribeDestinationReq *message, + uint8_t *out); +size_t sr__unsubscribe_destination_req__pack_to_buffer + (const Sr__UnsubscribeDestinationReq *message, + ProtobufCBuffer *buffer); +Sr__UnsubscribeDestinationReq * + sr__unsubscribe_destination_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__unsubscribe_destination_req__free_unpacked + (Sr__UnsubscribeDestinationReq *message, + ProtobufCAllocator *allocator); +/* Sr__CommitTimeoutReq methods */ +void sr__commit_timeout_req__init + (Sr__CommitTimeoutReq *message); +size_t sr__commit_timeout_req__get_packed_size + (const Sr__CommitTimeoutReq *message); +size_t sr__commit_timeout_req__pack + (const Sr__CommitTimeoutReq *message, + uint8_t *out); +size_t sr__commit_timeout_req__pack_to_buffer + (const Sr__CommitTimeoutReq *message, + ProtobufCBuffer *buffer); +Sr__CommitTimeoutReq * + sr__commit_timeout_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__commit_timeout_req__free_unpacked + (Sr__CommitTimeoutReq *message, + ProtobufCAllocator *allocator); +/* Sr__OperDataTimeoutReq methods */ +void sr__oper_data_timeout_req__init + (Sr__OperDataTimeoutReq *message); +size_t sr__oper_data_timeout_req__get_packed_size + (const Sr__OperDataTimeoutReq *message); +size_t sr__oper_data_timeout_req__pack + (const Sr__OperDataTimeoutReq *message, + uint8_t *out); +size_t sr__oper_data_timeout_req__pack_to_buffer + (const Sr__OperDataTimeoutReq *message, + ProtobufCBuffer *buffer); +Sr__OperDataTimeoutReq * + sr__oper_data_timeout_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__oper_data_timeout_req__free_unpacked + (Sr__OperDataTimeoutReq *message, + ProtobufCAllocator *allocator); +/* Sr__InternalStateDataReq methods */ +void sr__internal_state_data_req__init + (Sr__InternalStateDataReq *message); +size_t sr__internal_state_data_req__get_packed_size + (const Sr__InternalStateDataReq *message); +size_t sr__internal_state_data_req__pack + (const Sr__InternalStateDataReq *message, + uint8_t *out); +size_t sr__internal_state_data_req__pack_to_buffer + (const Sr__InternalStateDataReq *message, + ProtobufCBuffer *buffer); +Sr__InternalStateDataReq * + sr__internal_state_data_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__internal_state_data_req__free_unpacked + (Sr__InternalStateDataReq *message, + ProtobufCAllocator *allocator); +/* Sr__NotifStoreCleanupReq methods */ +void sr__notif_store_cleanup_req__init + (Sr__NotifStoreCleanupReq *message); +size_t sr__notif_store_cleanup_req__get_packed_size + (const Sr__NotifStoreCleanupReq *message); +size_t sr__notif_store_cleanup_req__pack + (const Sr__NotifStoreCleanupReq *message, + uint8_t *out); +size_t sr__notif_store_cleanup_req__pack_to_buffer + (const Sr__NotifStoreCleanupReq *message, + ProtobufCBuffer *buffer); +Sr__NotifStoreCleanupReq * + sr__notif_store_cleanup_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__notif_store_cleanup_req__free_unpacked + (Sr__NotifStoreCleanupReq *message, + ProtobufCAllocator *allocator); +/* Sr__DelayedMsgReq methods */ +void sr__delayed_msg_req__init + (Sr__DelayedMsgReq *message); +size_t sr__delayed_msg_req__get_packed_size + (const Sr__DelayedMsgReq *message); +size_t sr__delayed_msg_req__pack + (const Sr__DelayedMsgReq *message, + uint8_t *out); +size_t sr__delayed_msg_req__pack_to_buffer + (const Sr__DelayedMsgReq *message, + ProtobufCBuffer *buffer); +Sr__DelayedMsgReq * + sr__delayed_msg_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__delayed_msg_req__free_unpacked + (Sr__DelayedMsgReq *message, + ProtobufCAllocator *allocator); +/* Sr__NacmReloadReq methods */ +void sr__nacm_reload_req__init + (Sr__NacmReloadReq *message); +size_t sr__nacm_reload_req__get_packed_size + (const Sr__NacmReloadReq *message); +size_t sr__nacm_reload_req__pack + (const Sr__NacmReloadReq *message, + uint8_t *out); +size_t sr__nacm_reload_req__pack_to_buffer + (const Sr__NacmReloadReq *message, + ProtobufCBuffer *buffer); +Sr__NacmReloadReq * + sr__nacm_reload_req__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__nacm_reload_req__free_unpacked + (Sr__NacmReloadReq *message, + ProtobufCAllocator *allocator); +/* Sr__Request methods */ +void sr__request__init + (Sr__Request *message); +size_t sr__request__get_packed_size + (const Sr__Request *message); +size_t sr__request__pack + (const Sr__Request *message, + uint8_t *out); +size_t sr__request__pack_to_buffer + (const Sr__Request *message, + ProtobufCBuffer *buffer); +Sr__Request * + sr__request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__request__free_unpacked + (Sr__Request *message, + ProtobufCAllocator *allocator); +/* Sr__Response methods */ +void sr__response__init + (Sr__Response *message); +size_t sr__response__get_packed_size + (const Sr__Response *message); +size_t sr__response__pack + (const Sr__Response *message, + uint8_t *out); +size_t sr__response__pack_to_buffer + (const Sr__Response *message, + ProtobufCBuffer *buffer); +Sr__Response * + sr__response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__response__free_unpacked + (Sr__Response *message, + ProtobufCAllocator *allocator); +/* Sr__Notification methods */ +void sr__notification__init + (Sr__Notification *message); +size_t sr__notification__get_packed_size + (const Sr__Notification *message); +size_t sr__notification__pack + (const Sr__Notification *message, + uint8_t *out); +size_t sr__notification__pack_to_buffer + (const Sr__Notification *message, + ProtobufCBuffer *buffer); +Sr__Notification * + sr__notification__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__notification__free_unpacked + (Sr__Notification *message, + ProtobufCAllocator *allocator); +/* Sr__NotificationAck methods */ +void sr__notification_ack__init + (Sr__NotificationAck *message); +size_t sr__notification_ack__get_packed_size + (const Sr__NotificationAck *message); +size_t sr__notification_ack__pack + (const Sr__NotificationAck *message, + uint8_t *out); +size_t sr__notification_ack__pack_to_buffer + (const Sr__NotificationAck *message, + ProtobufCBuffer *buffer); +Sr__NotificationAck * + sr__notification_ack__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__notification_ack__free_unpacked + (Sr__NotificationAck *message, + ProtobufCAllocator *allocator); +/* Sr__InternalRequest methods */ +void sr__internal_request__init + (Sr__InternalRequest *message); +size_t sr__internal_request__get_packed_size + (const Sr__InternalRequest *message); +size_t sr__internal_request__pack + (const Sr__InternalRequest *message, + uint8_t *out); +size_t sr__internal_request__pack_to_buffer + (const Sr__InternalRequest *message, + ProtobufCBuffer *buffer); +Sr__InternalRequest * + sr__internal_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__internal_request__free_unpacked + (Sr__InternalRequest *message, + ProtobufCAllocator *allocator); +/* Sr__Msg methods */ +void sr__msg__init + (Sr__Msg *message); +size_t sr__msg__get_packed_size + (const Sr__Msg *message); +size_t sr__msg__pack + (const Sr__Msg *message, + uint8_t *out); +size_t sr__msg__pack_to_buffer + (const Sr__Msg *message, + ProtobufCBuffer *buffer); +Sr__Msg * + sr__msg__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sr__msg__free_unpacked + (Sr__Msg *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*Sr__Value_Closure) + (const Sr__Value *message, + void *closure_data); +typedef void (*Sr__Node_Closure) + (const Sr__Node *message, + void *closure_data); +typedef void (*Sr__Error_Closure) + (const Sr__Error *message, + void *closure_data); +typedef void (*Sr__SessionStartReq_Closure) + (const Sr__SessionStartReq *message, + void *closure_data); +typedef void (*Sr__SessionStartResp_Closure) + (const Sr__SessionStartResp *message, + void *closure_data); +typedef void (*Sr__SessionStopReq_Closure) + (const Sr__SessionStopReq *message, + void *closure_data); +typedef void (*Sr__SessionStopResp_Closure) + (const Sr__SessionStopResp *message, + void *closure_data); +typedef void (*Sr__SessionRefreshReq_Closure) + (const Sr__SessionRefreshReq *message, + void *closure_data); +typedef void (*Sr__SessionRefreshResp_Closure) + (const Sr__SessionRefreshResp *message, + void *closure_data); +typedef void (*Sr__SessionCheckReq_Closure) + (const Sr__SessionCheckReq *message, + void *closure_data); +typedef void (*Sr__SessionCheckResp_Closure) + (const Sr__SessionCheckResp *message, + void *closure_data); +typedef void (*Sr__SessionSwitchDsReq_Closure) + (const Sr__SessionSwitchDsReq *message, + void *closure_data); +typedef void (*Sr__SessionSwitchDsResp_Closure) + (const Sr__SessionSwitchDsResp *message, + void *closure_data); +typedef void (*Sr__SessionSetOptsReq_Closure) + (const Sr__SessionSetOptsReq *message, + void *closure_data); +typedef void (*Sr__SessionSetOptsResp_Closure) + (const Sr__SessionSetOptsResp *message, + void *closure_data); +typedef void (*Sr__VersionVerifyReq_Closure) + (const Sr__VersionVerifyReq *message, + void *closure_data); +typedef void (*Sr__VersionVerifyResp_Closure) + (const Sr__VersionVerifyResp *message, + void *closure_data); +typedef void (*Sr__SchemaRevision_Closure) + (const Sr__SchemaRevision *message, + void *closure_data); +typedef void (*Sr__SchemaSubmodule_Closure) + (const Sr__SchemaSubmodule *message, + void *closure_data); +typedef void (*Sr__Schema_Closure) + (const Sr__Schema *message, + void *closure_data); +typedef void (*Sr__ListSchemasReq_Closure) + (const Sr__ListSchemasReq *message, + void *closure_data); +typedef void (*Sr__ListSchemasResp_Closure) + (const Sr__ListSchemasResp *message, + void *closure_data); +typedef void (*Sr__GetSchemaReq_Closure) + (const Sr__GetSchemaReq *message, + void *closure_data); +typedef void (*Sr__GetSchemaResp_Closure) + (const Sr__GetSchemaResp *message, + void *closure_data); +typedef void (*Sr__GetItemReq_Closure) + (const Sr__GetItemReq *message, + void *closure_data); +typedef void (*Sr__GetItemResp_Closure) + (const Sr__GetItemResp *message, + void *closure_data); +typedef void (*Sr__GetItemsReq_Closure) + (const Sr__GetItemsReq *message, + void *closure_data); +typedef void (*Sr__GetItemsResp_Closure) + (const Sr__GetItemsResp *message, + void *closure_data); +typedef void (*Sr__GetSubtreeReq_Closure) + (const Sr__GetSubtreeReq *message, + void *closure_data); +typedef void (*Sr__GetSubtreeResp_Closure) + (const Sr__GetSubtreeResp *message, + void *closure_data); +typedef void (*Sr__GetSubtreesReq_Closure) + (const Sr__GetSubtreesReq *message, + void *closure_data); +typedef void (*Sr__GetSubtreesResp_Closure) + (const Sr__GetSubtreesResp *message, + void *closure_data); +typedef void (*Sr__GetSubtreeChunkReq_Closure) + (const Sr__GetSubtreeChunkReq *message, + void *closure_data); +typedef void (*Sr__GetSubtreeChunkResp_Closure) + (const Sr__GetSubtreeChunkResp *message, + void *closure_data); +typedef void (*Sr__SetItemReq_Closure) + (const Sr__SetItemReq *message, + void *closure_data); +typedef void (*Sr__SetItemResp_Closure) + (const Sr__SetItemResp *message, + void *closure_data); +typedef void (*Sr__SetItemStrReq_Closure) + (const Sr__SetItemStrReq *message, + void *closure_data); +typedef void (*Sr__SetItemStrResp_Closure) + (const Sr__SetItemStrResp *message, + void *closure_data); +typedef void (*Sr__DeleteItemReq_Closure) + (const Sr__DeleteItemReq *message, + void *closure_data); +typedef void (*Sr__DeleteItemResp_Closure) + (const Sr__DeleteItemResp *message, + void *closure_data); +typedef void (*Sr__MoveItemReq_Closure) + (const Sr__MoveItemReq *message, + void *closure_data); +typedef void (*Sr__MoveItemResp_Closure) + (const Sr__MoveItemResp *message, + void *closure_data); +typedef void (*Sr__ValidateReq_Closure) + (const Sr__ValidateReq *message, + void *closure_data); +typedef void (*Sr__ValidateResp_Closure) + (const Sr__ValidateResp *message, + void *closure_data); +typedef void (*Sr__CommitReq_Closure) + (const Sr__CommitReq *message, + void *closure_data); +typedef void (*Sr__CommitResp_Closure) + (const Sr__CommitResp *message, + void *closure_data); +typedef void (*Sr__DiscardChangesReq_Closure) + (const Sr__DiscardChangesReq *message, + void *closure_data); +typedef void (*Sr__DiscardChangesResp_Closure) + (const Sr__DiscardChangesResp *message, + void *closure_data); +typedef void (*Sr__CopyConfigReq_Closure) + (const Sr__CopyConfigReq *message, + void *closure_data); +typedef void (*Sr__CopyConfigResp_Closure) + (const Sr__CopyConfigResp *message, + void *closure_data); +typedef void (*Sr__LockReq_Closure) + (const Sr__LockReq *message, + void *closure_data); +typedef void (*Sr__LockResp_Closure) + (const Sr__LockResp *message, + void *closure_data); +typedef void (*Sr__UnlockReq_Closure) + (const Sr__UnlockReq *message, + void *closure_data); +typedef void (*Sr__UnlockResp_Closure) + (const Sr__UnlockResp *message, + void *closure_data); +typedef void (*Sr__SubscribeReq_Closure) + (const Sr__SubscribeReq *message, + void *closure_data); +typedef void (*Sr__SubscribeResp_Closure) + (const Sr__SubscribeResp *message, + void *closure_data); +typedef void (*Sr__UnsubscribeReq_Closure) + (const Sr__UnsubscribeReq *message, + void *closure_data); +typedef void (*Sr__UnsubscribeResp_Closure) + (const Sr__UnsubscribeResp *message, + void *closure_data); +typedef void (*Sr__CheckEnabledRunningReq_Closure) + (const Sr__CheckEnabledRunningReq *message, + void *closure_data); +typedef void (*Sr__CheckEnabledRunningResp_Closure) + (const Sr__CheckEnabledRunningResp *message, + void *closure_data); +typedef void (*Sr__ModuleInstallNotification_Closure) + (const Sr__ModuleInstallNotification *message, + void *closure_data); +typedef void (*Sr__FeatureEnableNotification_Closure) + (const Sr__FeatureEnableNotification *message, + void *closure_data); +typedef void (*Sr__ModuleChangeNotification_Closure) + (const Sr__ModuleChangeNotification *message, + void *closure_data); +typedef void (*Sr__SubtreeChangeNotification_Closure) + (const Sr__SubtreeChangeNotification *message, + void *closure_data); +typedef void (*Sr__Change_Closure) + (const Sr__Change *message, + void *closure_data); +typedef void (*Sr__GetChangesReq_Closure) + (const Sr__GetChangesReq *message, + void *closure_data); +typedef void (*Sr__GetChangesResp_Closure) + (const Sr__GetChangesResp *message, + void *closure_data); +typedef void (*Sr__CheckExecPermReq_Closure) + (const Sr__CheckExecPermReq *message, + void *closure_data); +typedef void (*Sr__CheckExecPermResp_Closure) + (const Sr__CheckExecPermResp *message, + void *closure_data); +typedef void (*Sr__RPCReq_Closure) + (const Sr__RPCReq *message, + void *closure_data); +typedef void (*Sr__RPCResp_Closure) + (const Sr__RPCResp *message, + void *closure_data); +typedef void (*Sr__EventNotifReq_Closure) + (const Sr__EventNotifReq *message, + void *closure_data); +typedef void (*Sr__EventNotifResp_Closure) + (const Sr__EventNotifResp *message, + void *closure_data); +typedef void (*Sr__EventNotifReplayReq_Closure) + (const Sr__EventNotifReplayReq *message, + void *closure_data); +typedef void (*Sr__EventNotifReplayResp_Closure) + (const Sr__EventNotifReplayResp *message, + void *closure_data); +typedef void (*Sr__DataProvideReq_Closure) + (const Sr__DataProvideReq *message, + void *closure_data); +typedef void (*Sr__DataProvideResp_Closure) + (const Sr__DataProvideResp *message, + void *closure_data); +typedef void (*Sr__ModuleInstallReq_Closure) + (const Sr__ModuleInstallReq *message, + void *closure_data); +typedef void (*Sr__ModuleInstallResp_Closure) + (const Sr__ModuleInstallResp *message, + void *closure_data); +typedef void (*Sr__FeatureEnableReq_Closure) + (const Sr__FeatureEnableReq *message, + void *closure_data); +typedef void (*Sr__FeatureEnableResp_Closure) + (const Sr__FeatureEnableResp *message, + void *closure_data); +typedef void (*Sr__UnsubscribeDestinationReq_Closure) + (const Sr__UnsubscribeDestinationReq *message, + void *closure_data); +typedef void (*Sr__CommitTimeoutReq_Closure) + (const Sr__CommitTimeoutReq *message, + void *closure_data); +typedef void (*Sr__OperDataTimeoutReq_Closure) + (const Sr__OperDataTimeoutReq *message, + void *closure_data); +typedef void (*Sr__InternalStateDataReq_Closure) + (const Sr__InternalStateDataReq *message, + void *closure_data); +typedef void (*Sr__NotifStoreCleanupReq_Closure) + (const Sr__NotifStoreCleanupReq *message, + void *closure_data); +typedef void (*Sr__DelayedMsgReq_Closure) + (const Sr__DelayedMsgReq *message, + void *closure_data); +typedef void (*Sr__NacmReloadReq_Closure) + (const Sr__NacmReloadReq *message, + void *closure_data); +typedef void (*Sr__Request_Closure) + (const Sr__Request *message, + void *closure_data); +typedef void (*Sr__Response_Closure) + (const Sr__Response *message, + void *closure_data); +typedef void (*Sr__Notification_Closure) + (const Sr__Notification *message, + void *closure_data); +typedef void (*Sr__NotificationAck_Closure) + (const Sr__NotificationAck *message, + void *closure_data); +typedef void (*Sr__InternalRequest_Closure) + (const Sr__InternalRequest *message, + void *closure_data); +typedef void (*Sr__Msg_Closure) + (const Sr__Msg *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor sr__api_variant__descriptor; +extern const ProtobufCEnumDescriptor sr__data_store__descriptor; +extern const ProtobufCEnumDescriptor sr__session_flags__descriptor; +extern const ProtobufCEnumDescriptor sr__edit_flags__descriptor; +extern const ProtobufCEnumDescriptor sr__subscription_type__descriptor; +extern const ProtobufCEnumDescriptor sr__notification_event__descriptor; +extern const ProtobufCEnumDescriptor sr__module_state__descriptor; +extern const ProtobufCEnumDescriptor sr__change_operation__descriptor; +extern const ProtobufCEnumDescriptor sr__operation__descriptor; +extern const ProtobufCMessageDescriptor sr__value__descriptor; +extern const ProtobufCEnumDescriptor sr__value__types__descriptor; +extern const ProtobufCMessageDescriptor sr__node__descriptor; +extern const ProtobufCMessageDescriptor sr__error__descriptor; +extern const ProtobufCMessageDescriptor sr__session_start_req__descriptor; +extern const ProtobufCMessageDescriptor sr__session_start_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__session_stop_req__descriptor; +extern const ProtobufCMessageDescriptor sr__session_stop_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__session_refresh_req__descriptor; +extern const ProtobufCMessageDescriptor sr__session_refresh_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__session_check_req__descriptor; +extern const ProtobufCMessageDescriptor sr__session_check_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__session_switch_ds_req__descriptor; +extern const ProtobufCMessageDescriptor sr__session_switch_ds_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__session_set_opts_req__descriptor; +extern const ProtobufCMessageDescriptor sr__session_set_opts_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__version_verify_req__descriptor; +extern const ProtobufCMessageDescriptor sr__version_verify_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__schema_revision__descriptor; +extern const ProtobufCMessageDescriptor sr__schema_submodule__descriptor; +extern const ProtobufCMessageDescriptor sr__schema__descriptor; +extern const ProtobufCMessageDescriptor sr__list_schemas_req__descriptor; +extern const ProtobufCMessageDescriptor sr__list_schemas_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__get_schema_req__descriptor; +extern const ProtobufCMessageDescriptor sr__get_schema_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__get_item_req__descriptor; +extern const ProtobufCMessageDescriptor sr__get_item_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__get_items_req__descriptor; +extern const ProtobufCMessageDescriptor sr__get_items_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__get_subtree_req__descriptor; +extern const ProtobufCMessageDescriptor sr__get_subtree_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__get_subtrees_req__descriptor; +extern const ProtobufCMessageDescriptor sr__get_subtrees_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__get_subtree_chunk_req__descriptor; +extern const ProtobufCMessageDescriptor sr__get_subtree_chunk_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__set_item_req__descriptor; +extern const ProtobufCMessageDescriptor sr__set_item_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__set_item_str_req__descriptor; +extern const ProtobufCMessageDescriptor sr__set_item_str_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__delete_item_req__descriptor; +extern const ProtobufCMessageDescriptor sr__delete_item_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__move_item_req__descriptor; +extern const ProtobufCEnumDescriptor sr__move_item_req__move_position__descriptor; +extern const ProtobufCMessageDescriptor sr__move_item_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__validate_req__descriptor; +extern const ProtobufCMessageDescriptor sr__validate_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__commit_req__descriptor; +extern const ProtobufCMessageDescriptor sr__commit_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__discard_changes_req__descriptor; +extern const ProtobufCMessageDescriptor sr__discard_changes_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__copy_config_req__descriptor; +extern const ProtobufCMessageDescriptor sr__copy_config_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__lock_req__descriptor; +extern const ProtobufCMessageDescriptor sr__lock_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__unlock_req__descriptor; +extern const ProtobufCMessageDescriptor sr__unlock_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__subscribe_req__descriptor; +extern const ProtobufCMessageDescriptor sr__subscribe_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__unsubscribe_req__descriptor; +extern const ProtobufCMessageDescriptor sr__unsubscribe_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__check_enabled_running_req__descriptor; +extern const ProtobufCMessageDescriptor sr__check_enabled_running_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__module_install_notification__descriptor; +extern const ProtobufCMessageDescriptor sr__feature_enable_notification__descriptor; +extern const ProtobufCMessageDescriptor sr__module_change_notification__descriptor; +extern const ProtobufCMessageDescriptor sr__subtree_change_notification__descriptor; +extern const ProtobufCMessageDescriptor sr__change__descriptor; +extern const ProtobufCMessageDescriptor sr__get_changes_req__descriptor; +extern const ProtobufCMessageDescriptor sr__get_changes_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__check_exec_perm_req__descriptor; +extern const ProtobufCMessageDescriptor sr__check_exec_perm_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__rpcreq__descriptor; +extern const ProtobufCMessageDescriptor sr__rpcresp__descriptor; +extern const ProtobufCMessageDescriptor sr__event_notif_req__descriptor; +extern const ProtobufCEnumDescriptor sr__event_notif_req__notif_type__descriptor; +extern const ProtobufCEnumDescriptor sr__event_notif_req__notif_flags__descriptor; +extern const ProtobufCMessageDescriptor sr__event_notif_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__event_notif_replay_req__descriptor; +extern const ProtobufCMessageDescriptor sr__event_notif_replay_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__data_provide_req__descriptor; +extern const ProtobufCMessageDescriptor sr__data_provide_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__module_install_req__descriptor; +extern const ProtobufCMessageDescriptor sr__module_install_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__feature_enable_req__descriptor; +extern const ProtobufCMessageDescriptor sr__feature_enable_resp__descriptor; +extern const ProtobufCMessageDescriptor sr__unsubscribe_destination_req__descriptor; +extern const ProtobufCMessageDescriptor sr__commit_timeout_req__descriptor; +extern const ProtobufCMessageDescriptor sr__oper_data_timeout_req__descriptor; +extern const ProtobufCMessageDescriptor sr__internal_state_data_req__descriptor; +extern const ProtobufCMessageDescriptor sr__notif_store_cleanup_req__descriptor; +extern const ProtobufCMessageDescriptor sr__delayed_msg_req__descriptor; +extern const ProtobufCMessageDescriptor sr__nacm_reload_req__descriptor; +extern const ProtobufCMessageDescriptor sr__request__descriptor; +extern const ProtobufCMessageDescriptor sr__response__descriptor; +extern const ProtobufCMessageDescriptor sr__notification__descriptor; +extern const ProtobufCMessageDescriptor sr__notification_ack__descriptor; +extern const ProtobufCMessageDescriptor sr__internal_request__descriptor; +extern const ProtobufCMessageDescriptor sr__msg__descriptor; +extern const ProtobufCEnumDescriptor sr__msg__msg_type__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_sysrepo_2eproto__INCLUDED */