engines/librpma_gpspm_flush.pb-c.c

   1 /*
   2  * Copyright 2020, Intel Corporation
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License,
   6  * version 2 as published by the Free Software Foundation..
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 /* Generated by the protocol buffer compiler. DO NOT EDIT! */
  15 /* Generated from: librpma_gpspm_flush.proto */
  16
  17 /* Do not generate deprecated warnings for self */
  18 #ifndef PROTOBUF_C__NO_DEPRECATED
  19 #define PROTOBUF_C__NO_DEPRECATED
  20 #endif
  21
  22 #include "librpma_gpspm_flush.pb-c.h"
  23 void   gpspm_flush_request__init
  24                      (GPSPMFlushRequest         *message)
  25 {
  26   static const GPSPMFlushRequest init_value = GPSPM_FLUSH_REQUEST__INIT;
  27   *message = init_value;
  28 }
  29 size_t gpspm_flush_request__get_packed_size
  30                      (const GPSPMFlushRequest *message)
  31 {
  32   assert(message->base.descriptor == &gpspm_flush_request__descriptor);
  33   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  34 }
  35 size_t gpspm_flush_request__pack
  36                      (const GPSPMFlushRequest *message,
  37                       uint8_t       *out)
  38 {
  39   assert(message->base.descriptor == &gpspm_flush_request__descriptor);
  40   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  41 }
  42 size_t gpspm_flush_request__pack_to_buffer
  43                      (const GPSPMFlushRequest *message,
  44                       ProtobufCBuffer *buffer)
  45 {
  46   assert(message->base.descriptor == &gpspm_flush_request__descriptor);
  47   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  48 }
  49 GPSPMFlushRequest *
  50        gpspm_flush_request__unpack
  51                      (ProtobufCAllocator  *allocator,
  52                       size_t               len,
  53                       const uint8_t       *data)
  54 {
  55   return (GPSPMFlushRequest *)
  56      protobuf_c_message_unpack (&gpspm_flush_request__descriptor,
  57                                 allocator, len, data);
  58 }
  59 void   gpspm_flush_request__free_unpacked
  60                      (GPSPMFlushRequest *message,
  61                       ProtobufCAllocator *allocator)
  62 {
  63   if(!message)
  64     return;
  65   assert(message->base.descriptor == &gpspm_flush_request__descriptor);
  66   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  67 }
  68 void   gpspm_flush_response__init
  69                      (GPSPMFlushResponse         *message)
  70 {
  71   static const GPSPMFlushResponse init_value = GPSPM_FLUSH_RESPONSE__INIT;
  72   *message = init_value;
  73 }
  74 size_t gpspm_flush_response__get_packed_size
  75                      (const GPSPMFlushResponse *message)
  76 {
  77   assert(message->base.descriptor == &gpspm_flush_response__descriptor);
  78   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  79 }
  80 size_t gpspm_flush_response__pack
  81                      (const GPSPMFlushResponse *message,
  82                       uint8_t       *out)
  83 {
  84   assert(message->base.descriptor == &gpspm_flush_response__descriptor);
  85   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  86 }
  87 size_t gpspm_flush_response__pack_to_buffer
  88                      (const GPSPMFlushResponse *message,
  89                       ProtobufCBuffer *buffer)
  90 {
  91   assert(message->base.descriptor == &gpspm_flush_response__descriptor);
  92   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  93 }
  94 GPSPMFlushResponse *
  95        gpspm_flush_response__unpack
  96                      (ProtobufCAllocator  *allocator,
  97                       size_t               len,
  98                       const uint8_t       *data)
  99 {
 100   return (GPSPMFlushResponse *)
 101      protobuf_c_message_unpack (&gpspm_flush_response__descriptor,
 102                                 allocator, len, data);
 103 }
 104 void   gpspm_flush_response__free_unpacked
 105                      (GPSPMFlushResponse *message,
 106                       ProtobufCAllocator *allocator)
 107 {
 108   if(!message)
 109     return;
 110   assert(message->base.descriptor == &gpspm_flush_response__descriptor);
 111   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 112 }
 113 static const ProtobufCFieldDescriptor gpspm_flush_request__field_descriptors[3] =
 114 {
 115   {
 116     "offset",
 117     1,
 118     PROTOBUF_C_LABEL_REQUIRED,
 119     PROTOBUF_C_TYPE_FIXED64,
 120     0,   /* quantifier_offset */
 121     offsetof(GPSPMFlushRequest, offset),
 122     NULL,
 123     NULL,
 124     0,             /* flags */
 125     0,NULL,NULL    /* reserved1,reserved2, etc */
 126   },
 127   {
 128     "length",
 129     2,
 130     PROTOBUF_C_LABEL_REQUIRED,
 131     PROTOBUF_C_TYPE_FIXED64,
 132     0,   /* quantifier_offset */
 133     offsetof(GPSPMFlushRequest, length),
 134     NULL,
 135     NULL,
 136     0,             /* flags */
 137     0,NULL,NULL    /* reserved1,reserved2, etc */
 138   },
 139   {
 140     "op_context",
 141     3,
 142     PROTOBUF_C_LABEL_REQUIRED,
 143     PROTOBUF_C_TYPE_FIXED64,
 144     0,   /* quantifier_offset */
 145     offsetof(GPSPMFlushRequest, op_context),
 146     NULL,
 147     NULL,
 148     0,             /* flags */
 149     0,NULL,NULL    /* reserved1,reserved2, etc */
 150   },
 151 };
 152 static const unsigned gpspm_flush_request__field_indices_by_name[] = {
 153   1,   /* field[1] = length */
 154   0,   /* field[0] = offset */
 155   2,   /* field[2] = op_context */
 156 };
 157 static const ProtobufCIntRange gpspm_flush_request__number_ranges[1 + 1] =
 158 {
 159   { 1, 0 },
 160   { 0, 3 }
 161 };
 162 const ProtobufCMessageDescriptor gpspm_flush_request__descriptor =
 163 {
 164   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 165   "GPSPM_flush_request",
 166   "GPSPMFlushRequest",
 167   "GPSPMFlushRequest",
 168   "",
 169   sizeof(GPSPMFlushRequest),
 170   3,
 171   gpspm_flush_request__field_descriptors,
 172   gpspm_flush_request__field_indices_by_name,
 173   1,  gpspm_flush_request__number_ranges,
 174   (ProtobufCMessageInit) gpspm_flush_request__init,
 175   NULL,NULL,NULL    /* reserved[123] */
 176 };
 177 static const ProtobufCFieldDescriptor gpspm_flush_response__field_descriptors[1] =
 178 {
 179   {
 180     "op_context",
 181     1,
 182     PROTOBUF_C_LABEL_REQUIRED,
 183     PROTOBUF_C_TYPE_FIXED64,
 184     0,   /* quantifier_offset */
 185     offsetof(GPSPMFlushResponse, op_context),
 186     NULL,
 187     NULL,
 188     0,             /* flags */
 189     0,NULL,NULL    /* reserved1,reserved2, etc */
 190   },
 191 };
 192 static const unsigned gpspm_flush_response__field_indices_by_name[] = {
 193   0,   /* field[0] = op_context */
 194 };
 195 static const ProtobufCIntRange gpspm_flush_response__number_ranges[1 + 1] =
 196 {
 197   { 1, 0 },
 198   { 0, 1 }
 199 };
 200 const ProtobufCMessageDescriptor gpspm_flush_response__descriptor =
 201 {
 202   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 203   "GPSPM_flush_response",
 204   "GPSPMFlushResponse",
 205   "GPSPMFlushResponse",
 206   "",
 207   sizeof(GPSPMFlushResponse),
 208   1,
 209   gpspm_flush_response__field_descriptors,
 210   gpspm_flush_response__field_indices_by_name,
 211   1,  gpspm_flush_response__number_ranges,
 212   (ProtobufCMessageInit) gpspm_flush_response__init,
 213   NULL,NULL,NULL    /* reserved[123] */
 214 };