← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to protobuf/files/src/google/protobuf/message.h

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
protobuf/files/src/google/protobuf/message.h
1
 
// Protocol Buffers - Google's data interchange format
2
 
// Copyright 2008 Google Inc.  All rights reserved.
3
 
// http://code.google.com/p/protobuf/
4
 
//
5
 
// Redistribution and use in source and binary forms, with or without
6
 
// modification, are permitted provided that the following conditions are
7
 
// met:
8
 
//
9
 
//     * Redistributions of source code must retain the above copyright
10
 
// notice, this list of conditions and the following disclaimer.
11
 
//     * Redistributions in binary form must reproduce the above
12
 
// copyright notice, this list of conditions and the following disclaimer
13
 
// in the documentation and/or other materials provided with the
14
 
// distribution.
15
 
//     * Neither the name of Google Inc. nor the names of its
16
 
// contributors may be used to endorse or promote products derived from
17
 
// this software without specific prior written permission.
18
 
//
19
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20
 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21
 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22
 
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23
 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24
 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25
 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26
 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27
 
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28
 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29
 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
 
 
31
 
// Author: kenton@google.com (Kenton Varda)
32
 
//  Based on original Protocol Buffers design by
33
 
//  Sanjay Ghemawat, Jeff Dean, and others.
34
 
//
35
 
// Defines Message, the abstract interface implemented by non-lite
36
 
// protocol message objects.  Although it's possible to implement this
37
 
// interface manually, most users will use the protocol compiler to
38
 
// generate implementations.
39
 
//
40
 
// Example usage:
41
 
//
42
 
// Say you have a message defined as:
43
 
//
44
 
//   message Foo {
45
 
//     optional string text = 1;
46
 
//     repeated int32 numbers = 2;
47
 
//   }
48
 
//
49
 
// Then, if you used the protocol compiler to generate a class from the above
50
 
// definition, you could use it like so:
51
 
//
52
 
//   string data;  // Will store a serialized version of the message.
53
 
//
54
 
//   {
55
 
//     // Create a message and serialize it.
56
 
//     Foo foo;
57
 
//     foo.set_text("Hello World!");
58
 
//     foo.add_numbers(1);
59
 
//     foo.add_numbers(5);
60
 
//     foo.add_numbers(42);
61
 
//
62
 
//     foo.SerializeToString(&data);
63
 
//   }
64
 
//
65
 
//   {
66
 
//     // Parse the serialized message and check that it contains the
67
 
//     // correct data.
68
 
//     Foo foo;
69
 
//     foo.ParseFromString(data);
70
 
//
71
 
//     assert(foo.text() == "Hello World!");
72
 
//     assert(foo.numbers_size() == 3);
73
 
//     assert(foo.numbers(0) == 1);
74
 
//     assert(foo.numbers(1) == 5);
75
 
//     assert(foo.numbers(2) == 42);
76
 
//   }
77
 
//
78
 
//   {
79
 
//     // Same as the last block, but do it dynamically via the Message
80
 
//     // reflection interface.
81
 
//     Message* foo = new Foo;
82
 
//     Descriptor* descriptor = foo->GetDescriptor();
83
 
//
84
 
//     // Get the descriptors for the fields we're interested in and verify
85
 
//     // their types.
86
 
//     FieldDescriptor* text_field = descriptor->FindFieldByName("text");
87
 
//     assert(text_field != NULL);
88
 
//     assert(text_field->type() == FieldDescriptor::TYPE_STRING);
89
 
//     assert(text_field->label() == FieldDescriptor::TYPE_OPTIONAL);
90
 
//     FieldDescriptor* numbers_field = descriptor->FindFieldByName("numbers");
91
 
//     assert(numbers_field != NULL);
92
 
//     assert(numbers_field->type() == FieldDescriptor::TYPE_INT32);
93
 
//     assert(numbers_field->label() == FieldDescriptor::TYPE_REPEATED);
94
 
//
95
 
//     // Parse the message.
96
 
//     foo->ParseFromString(data);
97
 
//
98
 
//     // Use the reflection interface to examine the contents.
99
 
//     const Reflection* reflection = foo->GetReflection();
100
 
//     assert(reflection->GetString(foo, text_field) == "Hello World!");
101
 
//     assert(reflection->FieldSize(foo, numbers_field) == 3);
102
 
//     assert(reflection->GetRepeatedInt32(foo, numbers_field, 0) == 1);
103
 
//     assert(reflection->GetRepeatedInt32(foo, numbers_field, 1) == 5);
104
 
//     assert(reflection->GetRepeatedInt32(foo, numbers_field, 2) == 42);
105
 
//
106
 
//     delete foo;
107
 
//   }
108
 
 
109
 
#ifndef GOOGLE_PROTOBUF_MESSAGE_H__
110
 
#define GOOGLE_PROTOBUF_MESSAGE_H__
111
 
 
112
 
#include <vector>
113
 
#include <string>
114
 
 
115
 
#ifdef __DECCXX
116
 
// HP C++'s iosfwd doesn't work.
117
 
#include <iostream>
118
 
#else
119
 
#include <iosfwd>
120
 
#endif
121
 
 
122
 
#include <google/protobuf/message_lite.h>
123
 
 
124
 
#include <google/protobuf/stubs/common.h>
125
 
 
126
 
namespace google {
127
 
namespace protobuf {
128
 
 
129
 
// Defined in this file.
130
 
class Message;
131
 
class Reflection;
132
 
class MessageFactory;
133
 
 
134
 
// Defined in other files.
135
 
class Descriptor;            // descriptor.h
136
 
class FieldDescriptor;       // descriptor.h
137
 
class EnumDescriptor;        // descriptor.h
138
 
class EnumValueDescriptor;   // descriptor.h
139
 
namespace io {
140
 
  class ZeroCopyInputStream;   // zero_copy_stream.h
141
 
  class ZeroCopyOutputStream;  // zero_copy_stream.h
142
 
  class CodedInputStream;      // coded_stream.h
143
 
  class CodedOutputStream;     // coded_stream.h
144
 
}
145
 
class UnknownFieldSet;       // unknown_field_set.h
146
 
 
147
 
// A container to hold message metadata.
148
 
struct Metadata {
149
 
  const Descriptor* descriptor;
150
 
  const Reflection* reflection;
151
 
};
152
 
 
153
 
// Returns the EnumDescriptor for enum type E, which must be a
154
 
// proto-declared enum type.  Code generated by the protocol compiler
155
 
// will include specializations of this template for each enum type declared.
156
 
template <typename E>
157
 
const EnumDescriptor* GetEnumDescriptor();
158
 
 
159
 
// Abstract interface for protocol messages.
160
 
//
161
 
// See also MessageLite, which contains most every-day operations.  Message
162
 
// adds descriptors and reflection on top of that.
163
 
//
164
 
// The methods of this class that are virtual but not pure-virtual have
165
 
// default implementations based on reflection.  Message classes which are
166
 
// optimized for speed will want to override these with faster implementations,
167
 
// but classes optimized for code size may be happy with keeping them.  See
168
 
// the optimize_for option in descriptor.proto.
169
 
class LIBPROTOBUF_EXPORT Message : public MessageLite {
170
 
 public:
171
 
  inline Message() {}
172
 
  virtual ~Message();
173
 
 
174
 
  // Basic Operations ------------------------------------------------
175
 
 
176
 
  // Construct a new instance of the same type.  Ownership is passed to the
177
 
  // caller.  (This is also defined in MessageLite, but is defined again here
178
 
  // for return-type covariance.)
179
 
  virtual Message* New() const = 0;
180
 
 
181
 
  // Make this message into a copy of the given message.  The given message
182
 
  // must have the same descriptor, but need not necessarily be the same class.
183
 
  // By default this is just implemented as "Clear(); MergeFrom(from);".
184
 
  virtual void CopyFrom(const Message& from);
185
 
 
186
 
  // Merge the fields from the given message into this message.  Singular
187
 
  // fields will be overwritten, except for embedded messages which will
188
 
  // be merged.  Repeated fields will be concatenated.  The given message
189
 
  // must be of the same type as this message (i.e. the exact same class).
190
 
  virtual void MergeFrom(const Message& from);
191
 
 
192
 
  // Verifies that IsInitialized() returns true.  GOOGLE_CHECK-fails otherwise, with
193
 
  // a nice error message.
194
 
  void CheckInitialized() const;
195
 
 
196
 
  // Slowly build a list of all required fields that are not set.
197
 
  // This is much, much slower than IsInitialized() as it is implemented
198
 
  // purely via reflection.  Generally, you should not call this unless you
199
 
  // have already determined that an error exists by calling IsInitialized().
200
 
  void FindInitializationErrors(vector<string>* errors) const;
201
 
 
202
 
  // Like FindInitializationErrors, but joins all the strings, delimited by
203
 
  // commas, and returns them.
204
 
  string InitializationErrorString() const;
205
 
 
206
 
  // Clears all unknown fields from this message and all embedded messages.
207
 
  // Normally, if unknown tag numbers are encountered when parsing a message,
208
 
  // the tag and value are stored in the message's UnknownFieldSet and
209
 
  // then written back out when the message is serialized.  This allows servers
210
 
  // which simply route messages to other servers to pass through messages
211
 
  // that have new field definitions which they don't yet know about.  However,
212
 
  // this behavior can have security implications.  To avoid it, call this
213
 
  // method after parsing.
214
 
  //
215
 
  // See Reflection::GetUnknownFields() for more on unknown fields.
216
 
  virtual void DiscardUnknownFields();
217
 
 
218
 
  // Computes (an estimate of) the total number of bytes currently used for
219
 
  // storing the message in memory.  The default implementation calls the
220
 
  // Reflection object's SpaceUsed() method.
221
 
  virtual int SpaceUsed() const;
222
 
 
223
 
  // Debugging & Testing----------------------------------------------
224
 
 
225
 
  // Generates a human readable form of this message, useful for debugging
226
 
  // and other purposes.
227
 
  string DebugString() const;
228
 
  // Like DebugString(), but with less whitespace.
229
 
  string ShortDebugString() const;
230
 
  // Like DebugString(), but do not escape UTF-8 byte sequences.
231
 
  string Utf8DebugString() const;
232
 
  // Convenience function useful in GDB.  Prints DebugString() to stdout.
233
 
  void PrintDebugString() const;
234
 
 
235
 
  // Heavy I/O -------------------------------------------------------
236
 
  // Additional parsing and serialization methods not implemented by
237
 
  // MessageLite because they are not supported by the lite library.
238
 
 
239
 
  // Parse a protocol buffer from a file descriptor.  If successful, the entire
240
 
  // input will be consumed.
241
 
  bool ParseFromFileDescriptor(int file_descriptor);
242
 
  // Like ParseFromFileDescriptor(), but accepts messages that are missing
243
 
  // required fields.
244
 
  bool ParsePartialFromFileDescriptor(int file_descriptor);
245
 
  // Parse a protocol buffer from a C++ istream.  If successful, the entire
246
 
  // input will be consumed.
247
 
  bool ParseFromIstream(istream* input);
248
 
  // Like ParseFromIstream(), but accepts messages that are missing
249
 
  // required fields.
250
 
  bool ParsePartialFromIstream(istream* input);
251
 
 
252
 
  // Serialize the message and write it to the given file descriptor.  All
253
 
  // required fields must be set.
254
 
  bool SerializeToFileDescriptor(int file_descriptor) const;
255
 
  // Like SerializeToFileDescriptor(), but allows missing required fields.
256
 
  bool SerializePartialToFileDescriptor(int file_descriptor) const;
257
 
  // Serialize the message and write it to the given C++ ostream.  All
258
 
  // required fields must be set.
259
 
  bool SerializeToOstream(ostream* output) const;
260
 
  // Like SerializeToOstream(), but allows missing required fields.
261
 
  bool SerializePartialToOstream(ostream* output) const;
262
 
 
263
 
 
264
 
  // Reflection-based methods ----------------------------------------
265
 
  // These methods are pure-virtual in MessageLite, but Message provides
266
 
  // reflection-based default implementations.
267
 
 
268
 
  virtual string GetTypeName() const;
269
 
  virtual void Clear();
270
 
  virtual bool IsInitialized() const;
271
 
  virtual void CheckTypeAndMergeFrom(const MessageLite& other);
272
 
  virtual bool MergePartialFromCodedStream(io::CodedInputStream* input);
273
 
  virtual int ByteSize() const;
274
 
  virtual void SerializeWithCachedSizes(io::CodedOutputStream* output) const;
275
 
 
276
 
 private:
277
 
  // This is called only by the default implementation of ByteSize(), to
278
 
  // update the cached size.  If you override ByteSize(), you do not need
279
 
  // to override this.  If you do not override ByteSize(), you MUST override
280
 
  // this; the default implementation will crash.
281
 
  //
282
 
  // The method is private because subclasses should never call it; only
283
 
  // override it.  Yes, C++ lets you do that.  Crazy, huh?
284
 
  virtual void SetCachedSize(int size) const;
285
 
 
286
 
 public:
287
 
 
288
 
  // Introspection ---------------------------------------------------
289
 
 
290
 
  // Typedef for backwards-compatibility.
291
 
  typedef google::protobuf::Reflection Reflection;
292
 
 
293
 
  // Get a Descriptor for this message's type.  This describes what
294
 
  // fields the message contains, the types of those fields, etc.
295
 
  const Descriptor* GetDescriptor() const { return GetMetadata().descriptor; }
296
 
 
297
 
  // Get the Reflection interface for this Message, which can be used to
298
 
  // read and modify the fields of the Message dynamically (in other words,
299
 
  // without knowing the message type at compile time).  This object remains
300
 
  // property of the Message.
301
 
  //
302
 
  // This method remains virtual in case a subclass does not implement
303
 
  // reflection and wants to override the default behavior.
304
 
  virtual const Reflection* GetReflection() const {
305
 
    return GetMetadata().reflection;
306
 
  }
307
 
 
308
 
 protected:
309
 
  // Get a struct containing the metadata for the Message. Most subclasses only
310
 
  // need to implement this method, rather than the GetDescriptor() and
311
 
  // GetReflection() wrappers.
312
 
  virtual Metadata GetMetadata() const  = 0;
313
 
 
314
 
 
315
 
 private:
316
 
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
317
 
};
318
 
 
319
 
// This interface contains methods that can be used to dynamically access
320
 
// and modify the fields of a protocol message.  Their semantics are
321
 
// similar to the accessors the protocol compiler generates.
322
 
//
323
 
// To get the Reflection for a given Message, call Message::GetReflection().
324
 
//
325
 
// This interface is separate from Message only for efficiency reasons;
326
 
// the vast majority of implementations of Message will share the same
327
 
// implementation of Reflection (GeneratedMessageReflection,
328
 
// defined in generated_message.h), and all Messages of a particular class
329
 
// should share the same Reflection object (though you should not rely on
330
 
// the latter fact).
331
 
//
332
 
// There are several ways that these methods can be used incorrectly.  For
333
 
// example, any of the following conditions will lead to undefined
334
 
// results (probably assertion failures):
335
 
// - The FieldDescriptor is not a field of this message type.
336
 
// - The method called is not appropriate for the field's type.  For
337
 
//   each field type in FieldDescriptor::TYPE_*, there is only one
338
 
//   Get*() method, one Set*() method, and one Add*() method that is
339
 
//   valid for that type.  It should be obvious which (except maybe
340
 
//   for TYPE_BYTES, which are represented using strings in C++).
341
 
// - A Get*() or Set*() method for singular fields is called on a repeated
342
 
//   field.
343
 
// - GetRepeated*(), SetRepeated*(), or Add*() is called on a non-repeated
344
 
//   field.
345
 
// - The Message object passed to any method is not of the right type for
346
 
//   this Reflection object (i.e. message.GetReflection() != reflection).
347
 
//
348
 
// You might wonder why there is not any abstract representation for a field
349
 
// of arbitrary type.  E.g., why isn't there just a "GetField()" method that
350
 
// returns "const Field&", where "Field" is some class with accessors like
351
 
// "GetInt32Value()".  The problem is that someone would have to deal with
352
 
// allocating these Field objects.  For generated message classes, having to
353
 
// allocate space for an additional object to wrap every field would at least
354
 
// double the message's memory footprint, probably worse.  Allocating the
355
 
// objects on-demand, on the other hand, would be expensive and prone to
356
 
// memory leaks.  So, instead we ended up with this flat interface.
357
 
//
358
 
// TODO(kenton):  Create a utility class which callers can use to read and
359
 
//   write fields from a Reflection without paying attention to the type.
360
 
class LIBPROTOBUF_EXPORT Reflection {
361
 
 public:
362
 
  // TODO(kenton):  Remove parameter.
363
 
  inline Reflection() {}
364
 
  virtual ~Reflection();
365
 
 
366
 
  // Get the UnknownFieldSet for the message.  This contains fields which
367
 
  // were seen when the Message was parsed but were not recognized according
368
 
  // to the Message's definition.
369
 
  virtual const UnknownFieldSet& GetUnknownFields(
370
 
      const Message& message) const = 0;
371
 
  // Get a mutable pointer to the UnknownFieldSet for the message.  This
372
 
  // contains fields which were seen when the Message was parsed but were not
373
 
  // recognized according to the Message's definition.
374
 
  virtual UnknownFieldSet* MutableUnknownFields(Message* message) const = 0;
375
 
 
376
 
  // Estimate the amount of memory used by the message object.
377
 
  virtual int SpaceUsed(const Message& message) const = 0;
378
 
 
379
 
  // Check if the given non-repeated field is set.
380
 
  virtual bool HasField(const Message& message,
381
 
                        const FieldDescriptor* field) const = 0;
382
 
 
383
 
  // Get the number of elements of a repeated field.
384
 
  virtual int FieldSize(const Message& message,
385
 
                        const FieldDescriptor* field) const = 0;
386
 
 
387
 
  // Clear the value of a field, so that HasField() returns false or
388
 
  // FieldSize() returns zero.
389
 
  virtual void ClearField(Message* message,
390
 
                          const FieldDescriptor* field) const = 0;
391
 
 
392
 
  // Remove the last element of a repeated field.
393
 
  // We don't provide a way to remove any element other than the last
394
 
  // because it invites inefficient use, such as O(n^2) filtering loops
395
 
  // that should have been O(n).  If you want to remove an element other
396
 
  // than the last, the best way to do it is to re-arrange the elements
397
 
  // (using Swap()) so that the one you want removed is at the end, then
398
 
  // call RemoveLast().
399
 
  virtual void RemoveLast(Message* message,
400
 
                          const FieldDescriptor* field) const = 0;
401
 
 
402
 
  // Swap the complete contents of two messages.
403
 
  virtual void Swap(Message* message1, Message* message2) const = 0;
404
 
 
405
 
  // Swap two elements of a repeated field.
406
 
  virtual void SwapElements(Message* message,
407
 
                    const FieldDescriptor* field,
408
 
                    int index1,
409
 
                    int index2) const = 0;
410
 
 
411
 
  // List all fields of the message which are currently set.  This includes
412
 
  // extensions.  Singular fields will only be listed if HasField(field) would
413
 
  // return true and repeated fields will only be listed if FieldSize(field)
414
 
  // would return non-zero.  Fields (both normal fields and extension fields)
415
 
  // will be listed ordered by field number.
416
 
  virtual void ListFields(const Message& message,
417
 
                          vector<const FieldDescriptor*>* output) const = 0;
418
 
 
419
 
  // Singular field getters ------------------------------------------
420
 
  // These get the value of a non-repeated field.  They return the default
421
 
  // value for fields that aren't set.
422
 
 
423
 
  virtual int32  GetInt32 (const Message& message,
424
 
                           const FieldDescriptor* field) const = 0;
425
 
  virtual int64  GetInt64 (const Message& message,
426
 
                           const FieldDescriptor* field) const = 0;
427
 
  virtual uint32 GetUInt32(const Message& message,
428
 
                           const FieldDescriptor* field) const = 0;
429
 
  virtual uint64 GetUInt64(const Message& message,
430
 
                           const FieldDescriptor* field) const = 0;
431
 
  virtual float  GetFloat (const Message& message,
432
 
                           const FieldDescriptor* field) const = 0;
433
 
  virtual double GetDouble(const Message& message,
434
 
                           const FieldDescriptor* field) const = 0;
435
 
  virtual bool   GetBool  (const Message& message,
436
 
                           const FieldDescriptor* field) const = 0;
437
 
  virtual string GetString(const Message& message,
438
 
                           const FieldDescriptor* field) const = 0;
439
 
  virtual const EnumValueDescriptor* GetEnum(
440
 
      const Message& message, const FieldDescriptor* field) const = 0;
441
 
  // See MutableMessage() for the meaning of the "factory" parameter.
442
 
  virtual const Message& GetMessage(const Message& message,
443
 
                                    const FieldDescriptor* field,
444
 
                                    MessageFactory* factory = NULL) const = 0;
445
 
 
446
 
  // Get a string value without copying, if possible.
447
 
  //
448
 
  // GetString() necessarily returns a copy of the string.  This can be
449
 
  // inefficient when the string is already stored in a string object in the
450
 
  // underlying message.  GetStringReference() will return a reference to the
451
 
  // underlying string in this case.  Otherwise, it will copy the string into
452
 
  // *scratch and return that.
453
 
  //
454
 
  // Note:  It is perfectly reasonable and useful to write code like:
455
 
  //     str = reflection->GetStringReference(field, &str);
456
 
  //   This line would ensure that only one copy of the string is made
457
 
  //   regardless of the field's underlying representation.  When initializing
458
 
  //   a newly-constructed string, though, it's just as fast and more readable
459
 
  //   to use code like:
460
 
  //     string str = reflection->GetString(field);
461
 
  virtual const string& GetStringReference(const Message& message,
462
 
                                           const FieldDescriptor* field,
463
 
                                           string* scratch) const = 0;
464
 
 
465
 
 
466
 
  // Singular field mutators -----------------------------------------
467
 
  // These mutate the value of a non-repeated field.
468
 
 
469
 
  virtual void SetInt32 (Message* message,
470
 
                         const FieldDescriptor* field, int32  value) const = 0;
471
 
  virtual void SetInt64 (Message* message,
472
 
                         const FieldDescriptor* field, int64  value) const = 0;
473
 
  virtual void SetUInt32(Message* message,
474
 
                         const FieldDescriptor* field, uint32 value) const = 0;
475
 
  virtual void SetUInt64(Message* message,
476
 
                         const FieldDescriptor* field, uint64 value) const = 0;
477
 
  virtual void SetFloat (Message* message,
478
 
                         const FieldDescriptor* field, float  value) const = 0;
479
 
  virtual void SetDouble(Message* message,
480
 
                         const FieldDescriptor* field, double value) const = 0;
481
 
  virtual void SetBool  (Message* message,
482
 
                         const FieldDescriptor* field, bool   value) const = 0;
483
 
  virtual void SetString(Message* message,
484
 
                         const FieldDescriptor* field,
485
 
                         const string& value) const = 0;
486
 
  virtual void SetEnum  (Message* message,
487
 
                         const FieldDescriptor* field,
488
 
                         const EnumValueDescriptor* value) const = 0;
489
 
  // Get a mutable pointer to a field with a message type.  If a MessageFactory
490
 
  // is provided, it will be used to construct instances of the sub-message;
491
 
  // otherwise, the default factory is used.  If the field is an extension that
492
 
  // does not live in the same pool as the containing message's descriptor (e.g.
493
 
  // it lives in an overlay pool), then a MessageFactory must be provided.
494
 
  // If you have no idea what that meant, then you probably don't need to worry
495
 
  // about it (don't provide a MessageFactory).  WARNING:  If the
496
 
  // FieldDescriptor is for a compiled-in extension, then
497
 
  // factory->GetPrototype(field->message_type() MUST return an instance of the
498
 
  // compiled-in class for this type, NOT DynamicMessage.
499
 
  virtual Message* MutableMessage(Message* message,
500
 
                                  const FieldDescriptor* field,
501
 
                                  MessageFactory* factory = NULL) const = 0;
502
 
 
503
 
 
504
 
  // Repeated field getters ------------------------------------------
505
 
  // These get the value of one element of a repeated field.
506
 
 
507
 
  virtual int32  GetRepeatedInt32 (const Message& message,
508
 
                                   const FieldDescriptor* field,
509
 
                                   int index) const = 0;
510
 
  virtual int64  GetRepeatedInt64 (const Message& message,
511
 
                                   const FieldDescriptor* field,
512
 
                                   int index) const = 0;
513
 
  virtual uint32 GetRepeatedUInt32(const Message& message,
514
 
                                   const FieldDescriptor* field,
515
 
                                   int index) const = 0;
516
 
  virtual uint64 GetRepeatedUInt64(const Message& message,
517
 
                                   const FieldDescriptor* field,
518
 
                                   int index) const = 0;
519
 
  virtual float  GetRepeatedFloat (const Message& message,
520
 
                                   const FieldDescriptor* field,
521
 
                                   int index) const = 0;
522
 
  virtual double GetRepeatedDouble(const Message& message,
523
 
                                   const FieldDescriptor* field,
524
 
                                   int index) const = 0;
525
 
  virtual bool   GetRepeatedBool  (const Message& message,
526
 
                                   const FieldDescriptor* field,
527
 
                                   int index) const = 0;
528
 
  virtual string GetRepeatedString(const Message& message,
529
 
                                   const FieldDescriptor* field,
530
 
                                   int index) const = 0;
531
 
  virtual const EnumValueDescriptor* GetRepeatedEnum(
532
 
      const Message& message,
533
 
      const FieldDescriptor* field, int index) const = 0;
534
 
  virtual const Message& GetRepeatedMessage(
535
 
      const Message& message,
536
 
      const FieldDescriptor* field, int index) const = 0;
537
 
 
538
 
  // See GetStringReference(), above.
539
 
  virtual const string& GetRepeatedStringReference(
540
 
      const Message& message, const FieldDescriptor* field,
541
 
      int index, string* scratch) const = 0;
542
 
 
543
 
 
544
 
  // Repeated field mutators -----------------------------------------
545
 
  // These mutate the value of one element of a repeated field.
546
 
 
547
 
  virtual void SetRepeatedInt32 (Message* message,
548
 
                                 const FieldDescriptor* field,
549
 
                                 int index, int32  value) const = 0;
550
 
  virtual void SetRepeatedInt64 (Message* message,
551
 
                                 const FieldDescriptor* field,
552
 
                                 int index, int64  value) const = 0;
553
 
  virtual void SetRepeatedUInt32(Message* message,
554
 
                                 const FieldDescriptor* field,
555
 
                                 int index, uint32 value) const = 0;
556
 
  virtual void SetRepeatedUInt64(Message* message,
557
 
                                 const FieldDescriptor* field,
558
 
                                 int index, uint64 value) const = 0;
559
 
  virtual void SetRepeatedFloat (Message* message,
560
 
                                 const FieldDescriptor* field,
561
 
                                 int index, float  value) const = 0;
562
 
  virtual void SetRepeatedDouble(Message* message,
563
 
                                 const FieldDescriptor* field,
564
 
                                 int index, double value) const = 0;
565
 
  virtual void SetRepeatedBool  (Message* message,
566
 
                                 const FieldDescriptor* field,
567
 
                                 int index, bool   value) const = 0;
568
 
  virtual void SetRepeatedString(Message* message,
569
 
                                 const FieldDescriptor* field,
570
 
                                 int index, const string& value) const = 0;
571
 
  virtual void SetRepeatedEnum(Message* message,
572
 
                               const FieldDescriptor* field, int index,
573
 
                               const EnumValueDescriptor* value) const = 0;
574
 
  // Get a mutable pointer to an element of a repeated field with a message
575
 
  // type.
576
 
  virtual Message* MutableRepeatedMessage(
577
 
      Message* message, const FieldDescriptor* field, int index) const = 0;
578
 
 
579
 
 
580
 
  // Repeated field adders -------------------------------------------
581
 
  // These add an element to a repeated field.
582
 
 
583
 
  virtual void AddInt32 (Message* message,
584
 
                         const FieldDescriptor* field, int32  value) const = 0;
585
 
  virtual void AddInt64 (Message* message,
586
 
                         const FieldDescriptor* field, int64  value) const = 0;
587
 
  virtual void AddUInt32(Message* message,
588
 
                         const FieldDescriptor* field, uint32 value) const = 0;
589
 
  virtual void AddUInt64(Message* message,
590
 
                         const FieldDescriptor* field, uint64 value) const = 0;
591
 
  virtual void AddFloat (Message* message,
592
 
                         const FieldDescriptor* field, float  value) const = 0;
593
 
  virtual void AddDouble(Message* message,
594
 
                         const FieldDescriptor* field, double value) const = 0;
595
 
  virtual void AddBool  (Message* message,
596
 
                         const FieldDescriptor* field, bool   value) const = 0;
597
 
  virtual void AddString(Message* message,
598
 
                         const FieldDescriptor* field,
599
 
                         const string& value) const = 0;
600
 
  virtual void AddEnum  (Message* message,
601
 
                         const FieldDescriptor* field,
602
 
                         const EnumValueDescriptor* value) const = 0;
603
 
  // See MutableMessage() for comments on the "factory" parameter.
604
 
  virtual Message* AddMessage(Message* message,
605
 
                              const FieldDescriptor* field,
606
 
                              MessageFactory* factory = NULL) const = 0;
607
 
 
608
 
 
609
 
  // Extensions ------------------------------------------------------
610
 
 
611
 
  // Try to find an extension of this message type by fully-qualified field
612
 
  // name.  Returns NULL if no extension is known for this name or number.
613
 
  virtual const FieldDescriptor* FindKnownExtensionByName(
614
 
      const string& name) const = 0;
615
 
 
616
 
  // Try to find an extension of this message type by field number.
617
 
  // Returns NULL if no extension is known for this name or number.
618
 
  virtual const FieldDescriptor* FindKnownExtensionByNumber(
619
 
      int number) const = 0;
620
 
 
621
 
 private:
622
 
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reflection);
623
 
};
624
 
 
625
 
// Abstract interface for a factory for message objects.
626
 
class LIBPROTOBUF_EXPORT MessageFactory {
627
 
 public:
628
 
  inline MessageFactory() {}
629
 
  virtual ~MessageFactory();
630
 
 
631
 
  // Given a Descriptor, gets or constructs the default (prototype) Message
632
 
  // of that type.  You can then call that message's New() method to construct
633
 
  // a mutable message of that type.
634
 
  //
635
 
  // Calling this method twice with the same Descriptor returns the same
636
 
  // object.  The returned object remains property of the factory.  Also, any
637
 
  // objects created by calling the prototype's New() method share some data
638
 
  // with the prototype, so these must be destoyed before the MessageFactory
639
 
  // is destroyed.
640
 
  //
641
 
  // The given descriptor must outlive the returned message, and hence must
642
 
  // outlive the MessageFactory.
643
 
  //
644
 
  // Some implementations do not support all types.  GetPrototype() will
645
 
  // return NULL if the descriptor passed in is not supported.
646
 
  //
647
 
  // This method may or may not be thread-safe depending on the implementation.
648
 
  // Each implementation should document its own degree thread-safety.
649
 
  virtual const Message* GetPrototype(const Descriptor* type) = 0;
650
 
 
651
 
  // Gets a MessageFactory which supports all generated, compiled-in messages.
652
 
  // In other words, for any compiled-in type FooMessage, the following is true:
653
 
  //   MessageFactory::generated_factory()->GetPrototype(
654
 
  //     FooMessage::descriptor()) == FooMessage::default_instance()
655
 
  // This factory supports all types which are found in
656
 
  // DescriptorPool::generated_pool().  If given a descriptor from any other
657
 
  // pool, GetPrototype() will return NULL.  (You can also check if a
658
 
  // descriptor is for a generated message by checking if
659
 
  // descriptor->file()->pool() == DescriptorPool::generated_pool().)
660
 
  //
661
 
  // This factory is 100% thread-safe; calling GetPrototype() does not modify
662
 
  // any shared data.
663
 
  //
664
 
  // This factory is a singleton.  The caller must not delete the object.
665
 
  static MessageFactory* generated_factory();
666
 
 
667
 
  // For internal use only:  Registers a .proto file at static initialization
668
 
  // time, to be placed in generated_factory.  The first time GetPrototype()
669
 
  // is called with a descriptor from this file, |register_messages| will be
670
 
  // called, with the file name as the parameter.  It must call
671
 
  // InternalRegisterGeneratedMessage() (below) to register each message type
672
 
  // in the file.  This strange mechanism is necessary because descriptors are
673
 
  // built lazily, so we can't register types by their descriptor until we
674
 
  // know that the descriptor exists.  |filename| must be a permanent string.
675
 
  static void InternalRegisterGeneratedFile(
676
 
      const char* filename, void (*register_messages)(const string&));
677
 
 
678
 
  // For internal use only:  Registers a message type.  Called only by the
679
 
  // functions which are registered with InternalRegisterGeneratedFile(),
680
 
  // above.
681
 
  static void InternalRegisterGeneratedMessage(const Descriptor* descriptor,
682
 
                                               const Message* prototype);
683
 
 
684
 
 private:
685
 
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFactory);
686
 
};
687
 
 
688
 
}  // namespace protobuf
689
 
 
690
 
}  // namespace google
691
 
#endif  // GOOGLE_PROTOBUF_MESSAGE_H__