/[zanavi_public1]/navit/navit/maptool/google/protobuf-c/protobuf-c.h
ZANavi

Contents of /navit/navit/maptool/google/protobuf-c/protobuf-c.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 10 - (hide annotations) (download)
Fri Oct 28 21:43:09 2011 UTC (12 years, 5 months ago) by zoff99
File MIME type: text/plain
File size: 14845 byte(s)
import
1 zoff99 10 /* --- protobuf-c.h: public protobuf c runtime api --- */
2    
3     /*
4     * Copyright 2008, Dave Benson.
5     *
6     * Licensed under the Apache License, Version 2.0 (the "License");
7     * you may not use this file except in compliance with
8     * the License. You may obtain a copy of the License
9     * at http://www.apache.org/licenses/LICENSE-2.0 Unless
10     * required by applicable law or agreed to in writing,
11     * software distributed under the License is distributed on
12     * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
13     * KIND, either express or implied. See the License for the
14     * specific language governing permissions and limitations
15     * under the License.
16     */
17    
18     #ifndef __PROTOBUF_C_RUNTIME_H_
19     #define __PROTOBUF_C_RUNTIME_H_
20    
21     #include <stddef.h>
22     #include <assert.h>
23    
24     #ifdef __cplusplus
25     # define PROTOBUF_C_BEGIN_DECLS extern "C" {
26     # define PROTOBUF_C_END_DECLS }
27     #else
28     # define PROTOBUF_C_BEGIN_DECLS
29     # define PROTOBUF_C_END_DECLS
30     #endif
31    
32     #if !defined(PROTOBUF_C_NO_DEPRECATED) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
33     #define PROTOBUF_C_DEPRECATED __attribute__((__deprecated__))
34     #else
35     #define PROTOBUF_C_DEPRECATED
36     #endif
37    
38     /* Define int32_t, int64_t, uint32_t, uint64_t, uint8_t.
39    
40     Usually, just include <inttypes.h> to do the work.
41     XXX: should we use stdint.h?
42     */
43     #ifndef PROTOBUF_C_SKIP_INTTYPES_H
44     # if defined(_MSC_VER)
45     /* On windows, in ms visual studio, define the types ourselves */
46     # define int32_t signed __int32
47     # define uint32_t unsigned __int32
48     # define int64_t signed __int64
49     # define uint64_t unsigned __int64
50     # define uint8_t unsigned char
51     # else
52     /* Use the system inttypes.h */
53     # include <inttypes.h>
54     # endif
55     #endif
56    
57     PROTOBUF_C_BEGIN_DECLS
58    
59     typedef enum
60     {
61     PROTOBUF_C_LABEL_REQUIRED,
62     PROTOBUF_C_LABEL_OPTIONAL,
63     PROTOBUF_C_LABEL_REPEATED
64     } ProtobufCLabel;
65    
66     typedef enum
67     {
68     PROTOBUF_C_TYPE_INT32,
69     PROTOBUF_C_TYPE_SINT32,
70     PROTOBUF_C_TYPE_SFIXED32,
71     PROTOBUF_C_TYPE_INT64,
72     PROTOBUF_C_TYPE_SINT64,
73     PROTOBUF_C_TYPE_SFIXED64,
74     PROTOBUF_C_TYPE_UINT32,
75     PROTOBUF_C_TYPE_FIXED32,
76     PROTOBUF_C_TYPE_UINT64,
77     PROTOBUF_C_TYPE_FIXED64,
78     PROTOBUF_C_TYPE_FLOAT,
79     PROTOBUF_C_TYPE_DOUBLE,
80     PROTOBUF_C_TYPE_BOOL,
81     PROTOBUF_C_TYPE_ENUM,
82     PROTOBUF_C_TYPE_STRING,
83     PROTOBUF_C_TYPE_BYTES,
84     //PROTOBUF_C_TYPE_GROUP, // NOT SUPPORTED
85     PROTOBUF_C_TYPE_MESSAGE,
86     } ProtobufCType;
87    
88     typedef int protobuf_c_boolean;
89     #define PROTOBUF_C_OFFSETOF(struct, member) offsetof(struct, member)
90    
91     #define PROTOBUF_C_ASSERT(condition) assert(condition)
92     #define PROTOBUF_C_ASSERT_NOT_REACHED() assert(0)
93    
94     typedef struct _ProtobufCBinaryData ProtobufCBinaryData;
95     struct _ProtobufCBinaryData
96     {
97     size_t len;
98     uint8_t *data;
99     };
100    
101     typedef struct _ProtobufCIntRange ProtobufCIntRange; /* private */
102    
103     /* --- memory management --- */
104     typedef struct _ProtobufCAllocator ProtobufCAllocator;
105     struct _ProtobufCAllocator
106     {
107     void *(*alloc)(void *allocator_data, size_t size);
108     void (*free)(void *allocator_data, void *pointer);
109     void *(*tmp_alloc)(void *allocator_data, size_t size);
110     unsigned max_alloca;
111     void *allocator_data;
112     };
113    
114     /* This is a configurable allocator.
115     * By default, it uses the system allocator (meaning malloc() and free()).
116     * This is typically changed to adapt to frameworks that provide
117     * some nonstandard allocation functions.
118     *
119     * NOTE: you may modify this allocator.
120     */
121     extern ProtobufCAllocator protobuf_c_default_allocator; /* settable */
122    
123     /* This is the system allocator, meaning it uses malloc() and free().
124     *
125     * NOTE: please do NOT modify this allocator.
126     */
127     extern ProtobufCAllocator protobuf_c_system_allocator; /* use malloc, free etc */
128    
129     /* This is the function that our default allocators call when they
130     run out-of-memory. The default behavior of this function is to
131     terminate your program. */
132     extern void (*protobuf_c_out_of_memory) (void);
133    
134     /* --- append-only data buffer --- */
135     typedef struct _ProtobufCBuffer ProtobufCBuffer;
136     struct _ProtobufCBuffer
137     {
138     void (*append)(ProtobufCBuffer *buffer,
139     size_t len,
140     const uint8_t *data);
141     };
142     /* --- enums --- */
143     typedef struct _ProtobufCEnumValue ProtobufCEnumValue;
144     typedef struct _ProtobufCEnumValueIndex ProtobufCEnumValueIndex;
145     typedef struct _ProtobufCEnumDescriptor ProtobufCEnumDescriptor;
146    
147     /* ProtobufCEnumValue: this represents a single value of
148     * an enumeration.
149     * 'name' is the string identifying this value, as given in the .proto file.
150     * 'c_name' is the full name of the C enumeration value.
151     * 'value' is the number assigned to this value, as given in the .proto file.
152     */
153     struct _ProtobufCEnumValue
154     {
155     const char *name;
156     const char *c_name;
157     int value;
158     };
159    
160     /* ProtobufCEnumDescriptor: the represents the enum as a whole,
161     * with all its values.
162     * 'magic' is a code we check to ensure that the api is used correctly.
163     * 'name' is the qualified name (e.g. "namespace.Type").
164     * 'short_name' is the unqualified name ("Type"), as given in the .proto file.
165     * 'package_name' is the '.'-separated namespace
166     * 'n_values' is the number of distinct values.
167     * 'values' is the array of distinct values.
168     * 'n_value_names' number of named values (including aliases).
169     * 'value_names' are the named values (including aliases).
170     *
171     * The rest of the values are private essentially.
172     *
173     * see also: Use protobuf_c_enum_descriptor_get_value_by_name()
174     * and protobuf_c_enum_descriptor_get_value() to efficiently
175     * lookup values in the descriptor.
176     */
177     struct _ProtobufCEnumDescriptor
178     {
179     uint32_t magic;
180    
181     const char *name;
182     const char *short_name;
183     const char *c_name;
184     const char *package_name;
185    
186     /* sorted by value */
187     unsigned n_values;
188     const ProtobufCEnumValue *values;
189    
190     /* sorted by name */
191     unsigned n_value_names;
192     const ProtobufCEnumValueIndex *values_by_name;
193    
194     /* value-ranges, for faster lookups by number */
195     unsigned n_value_ranges;
196     const ProtobufCIntRange *value_ranges;
197    
198     void *reserved1;
199     void *reserved2;
200     void *reserved3;
201     void *reserved4;
202     };
203    
204     /* --- messages --- */
205     typedef struct _ProtobufCMessageDescriptor ProtobufCMessageDescriptor;
206     typedef struct _ProtobufCFieldDescriptor ProtobufCFieldDescriptor;
207     typedef struct _ProtobufCMessage ProtobufCMessage;
208     typedef void (*ProtobufCMessageInit)(ProtobufCMessage *);
209     /* ProtobufCFieldDescriptor: description of a single field
210     * in a message.
211     * 'name' is the name of the field, as given in the .proto file.
212     * 'id' is the code representing the field, as given in the .proto file.
213     * 'label' is one of PROTOBUF_C_LABEL_{REQUIRED,OPTIONAL,REPEATED}
214     * 'type' is the type of field.
215     * 'quantifier_offset' is the offset in bytes into the message's C structure
216     * for this member's "has_MEMBER" field (for optional members) or
217     * "n_MEMBER" field (for repeated members).
218     * 'offset' is the offset in bytes into the message's C structure
219     * for the member itself.
220     * 'descriptor' is a pointer to a ProtobufC{Enum,Message}Descriptor
221     * if type is PROTOBUF_C_TYPE_{ENUM,MESSAGE} respectively,
222     * otherwise NULL.
223     * 'default_value' is a pointer to a default value for this field,
224     * where allowed.
225     */
226     struct _ProtobufCFieldDescriptor
227     {
228     const char *name;
229     uint32_t id;
230     ProtobufCLabel label;
231     ProtobufCType type;
232     unsigned quantifier_offset;
233     unsigned offset;
234     const void *descriptor; /* for MESSAGE and ENUM types */
235     const void *default_value; /* or NULL if no default-value */
236     protobuf_c_boolean packed;
237    
238     unsigned reserved_flags;
239     void *reserved2;
240     void *reserved3;
241     };
242     /* ProtobufCMessageDescriptor: description of a message.
243     *
244     * 'magic' is a code we check to ensure that the api is used correctly.
245     * 'name' is the qualified name (e.g. "namespace.Type").
246     * 'short_name' is the unqualified name ("Type"), as given in the .proto file.
247     * 'c_name' is the c-formatted name of the structure
248     * 'package_name' is the '.'-separated namespace
249     * 'sizeof_message' is the size in bytes of the C structure
250     * representing an instance of this type of message.
251     * 'n_fields' is the number of known fields in this message.
252     * 'fields' is the fields sorted by id number.
253     * 'fields_sorted_by_name', 'n_field_ranges' and 'field_ranges'
254     * are used for looking up fields by name and id. (private)
255     */
256     struct _ProtobufCMessageDescriptor
257     {
258     uint32_t magic;
259    
260     const char *name;
261     const char *short_name;
262     const char *c_name;
263     const char *package_name;
264    
265     size_t sizeof_message;
266    
267     /* sorted by field-id */
268     unsigned n_fields;
269     const ProtobufCFieldDescriptor *fields;
270     const unsigned *fields_sorted_by_name;
271    
272     /* ranges, optimization for looking up fields */
273     unsigned n_field_ranges;
274     const ProtobufCIntRange *field_ranges;
275    
276     ProtobufCMessageInit message_init;
277     void *reserved1;
278     void *reserved2;
279     void *reserved3;
280     };
281    
282    
283     /* ProtobufCMessage: an instance of a message.
284     *
285     * ProtobufCMessage is sort-of a lightweight
286     * base-class for all messages.
287     *
288     * In particular, ProtobufCMessage doesn't have
289     * any allocation policy associated with it.
290     * That's because it is common to create ProtobufCMessage's
291     * on the stack. In fact, we that's what we recommend
292     * for sending messages (because if you just allocate from the
293     * stack, then you can't really have a memory leak).
294     *
295     * This means that functions like protobuf_c_message_unpack()
296     * which return a ProtobufCMessage must be paired
297     * with a free function, like protobuf_c_message_free_unpacked().
298     *
299     * 'descriptor' gives the locations and types of the members of message
300     * 'n_unknown_fields' is the number of fields we didn't recognize.
301     * 'unknown_fields' are fields we didn't recognize.
302     */
303     typedef struct _ProtobufCMessageUnknownField ProtobufCMessageUnknownField;
304     struct _ProtobufCMessage
305     {
306     const ProtobufCMessageDescriptor *descriptor;
307     unsigned n_unknown_fields;
308     ProtobufCMessageUnknownField *unknown_fields;
309     };
310     #define PROTOBUF_C_MESSAGE_INIT(descriptor) { descriptor, 0, NULL }
311    
312     /* To pack a message: you have two options:
313     (1) you can compute the size of the message
314     using protobuf_c_message_get_packed_size()
315     then pass protobuf_c_message_pack() a buffer of
316     that length.
317     (2) Provide a virtual buffer (a ProtobufCBuffer) to
318     accept data as we scan through it.
319     */
320     size_t protobuf_c_message_get_packed_size(const ProtobufCMessage *message);
321     size_t protobuf_c_message_pack (const ProtobufCMessage *message,
322     uint8_t *out);
323     size_t protobuf_c_message_pack_to_buffer (const ProtobufCMessage *message,
324     ProtobufCBuffer *buffer);
325    
326     ProtobufCMessage *
327     protobuf_c_message_unpack (const ProtobufCMessageDescriptor *,
328     ProtobufCAllocator *allocator,
329     size_t len,
330     const uint8_t *data);
331     void protobuf_c_message_free_unpacked (ProtobufCMessage *message,
332     ProtobufCAllocator *allocator);
333    
334     /* WARNING: 'message' must be a block of memory
335     of size descriptor->sizeof_message. */
336     #define protobuf_c_message_init(descriptor, message) ((descriptor)->message_init((ProtobufCMessage*) (message)))
337    
338     /* --- services --- */
339     typedef struct _ProtobufCMethodDescriptor ProtobufCMethodDescriptor;
340     typedef struct _ProtobufCServiceDescriptor ProtobufCServiceDescriptor;
341    
342     struct _ProtobufCMethodDescriptor
343     {
344     const char *name;
345     const ProtobufCMessageDescriptor *input;
346     const ProtobufCMessageDescriptor *output;
347     };
348     struct _ProtobufCServiceDescriptor
349     {
350     uint32_t magic;
351    
352     const char *name;
353     const char *short_name;
354     const char *c_name;
355     const char *package;
356     unsigned n_methods;
357     const ProtobufCMethodDescriptor *methods; /* in order from .proto file */
358     const unsigned *method_indices_by_name;
359     };
360    
361     typedef struct _ProtobufCService ProtobufCService;
362     typedef void (*ProtobufCClosure)(const ProtobufCMessage *message,
363     void *closure_data);
364     struct _ProtobufCService
365     {
366     const ProtobufCServiceDescriptor *descriptor;
367     void (*invoke)(ProtobufCService *service,
368     unsigned method_index,
369     const ProtobufCMessage *input,
370     ProtobufCClosure closure,
371     void *closure_data);
372     void (*destroy) (ProtobufCService *service);
373     };
374    
375    
376     void protobuf_c_service_destroy (ProtobufCService *);
377    
378    
379     /* --- querying the descriptors --- */
380     const ProtobufCEnumValue *
381     protobuf_c_enum_descriptor_get_value_by_name
382     (const ProtobufCEnumDescriptor *desc,
383     const char *name);
384     const ProtobufCEnumValue *
385     protobuf_c_enum_descriptor_get_value
386     (const ProtobufCEnumDescriptor *desc,
387     int value);
388     const ProtobufCFieldDescriptor *
389     protobuf_c_message_descriptor_get_field_by_name
390     (const ProtobufCMessageDescriptor *desc,
391     const char *name);
392     const ProtobufCFieldDescriptor *
393     protobuf_c_message_descriptor_get_field
394     (const ProtobufCMessageDescriptor *desc,
395     unsigned value);
396     const ProtobufCMethodDescriptor *
397     protobuf_c_service_descriptor_get_method_by_name
398     (const ProtobufCServiceDescriptor *desc,
399     const char *name);
400    
401     /* --- wire format enums --- */
402     typedef enum
403     {
404     PROTOBUF_C_WIRE_TYPE_VARINT,
405     PROTOBUF_C_WIRE_TYPE_64BIT,
406     PROTOBUF_C_WIRE_TYPE_LENGTH_PREFIXED,
407     PROTOBUF_C_WIRE_TYPE_START_GROUP, /* unsupported */
408     PROTOBUF_C_WIRE_TYPE_END_GROUP, /* unsupported */
409     PROTOBUF_C_WIRE_TYPE_32BIT
410     } ProtobufCWireType;
411    
412     /* --- unknown message fields --- */
413     struct _ProtobufCMessageUnknownField
414     {
415     uint32_t tag;
416     ProtobufCWireType wire_type;
417     size_t len;
418     uint8_t *data;
419     };
420    
421     /* --- extra (superfluous) api: trivial buffer --- */
422     typedef struct _ProtobufCBufferSimple ProtobufCBufferSimple;
423     struct _ProtobufCBufferSimple
424     {
425     ProtobufCBuffer base;
426     size_t alloced;
427     size_t len;
428     uint8_t *data;
429     protobuf_c_boolean must_free_data;
430     };
431     #define PROTOBUF_C_BUFFER_SIMPLE_INIT(array_of_bytes) \
432     { { protobuf_c_buffer_simple_append }, \
433     sizeof(array_of_bytes), 0, (array_of_bytes), 0 }
434     #define PROTOBUF_C_BUFFER_SIMPLE_CLEAR(simp_buf) \
435     do { if ((simp_buf)->must_free_data) \
436     protobuf_c_default_allocator.free (&protobuf_c_default_allocator.allocator_data, (simp_buf)->data); } while (0)
437    
438     /* ====== private ====== */
439     #include "protobuf-c-private.h"
440    
441    
442     PROTOBUF_C_END_DECLS
443    
444     #endif /* __PROTOBUF_C_RUNTIME_H_ */

   
Visit the ZANavi Wiki