← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/protobuf/src/google/protobuf/message_lite.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/protobuf/src/google/protobuf/message_lite.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
 
// Authors: wink@google.com (Wink Saville),
32
 
//          kenton@google.com (Kenton Varda)
33
 
//  Based on original Protocol Buffers design by
34
 
//  Sanjay Ghemawat, Jeff Dean, and others.
35
 
//
36
 
// Defines MessageLite, the abstract interface implemented by all (lite
37
 
// and non-lite) protocol message objects.
38
 
 
39
 
#ifndef GOOGLE_PROTOBUF_MESSAGE_LITE_H__
40
 
#define GOOGLE_PROTOBUF_MESSAGE_LITE_H__
41
 
 
42
 
#include <google/protobuf/stubs/common.h>
43
 
 
44
 
namespace google {
45
 
namespace protobuf {
46
 
 
47
 
namespace io {
48
 
  class CodedInputStream;
49
 
  class CodedOutputStream;
50
 
  class ZeroCopyInputStream;
51
 
  class ZeroCopyOutputStream;
52
 
}
53
 
 
54
 
// Interface to light weight protocol messages.
55
 
//
56
 
// This interface is implemented by all protocol message objects.  Non-lite
57
 
// messages additionally implement the Message interface, which is a
58
 
// subclass of MessageLite.  Use MessageLite instead when you only need
59
 
// the subset of features which it supports -- namely, nothing that uses
60
 
// descriptors or reflection.  You can instruct the protocol compiler
61
 
// to generate classes which implement only MessageLite, not the full
62
 
// Message interface, by adding the following line to the .proto file:
63
 
//
64
 
//   option optimize_for = LITE_RUNTIME;
65
 
//
66
 
// This is particularly useful on resource-constrained systems where
67
 
// the full protocol buffers runtime library is too big.
68
 
//
69
 
// Note that on non-constrained systems (e.g. servers) when you need
70
 
// to link in lots of protocol definitions, a better way to reduce
71
 
// total code footprint is to use optimize_for = CODE_SIZE.  This
72
 
// will make the generated code smaller while still supporting all the
73
 
// same features (at the expense of speed).  optimize_for = LITE_RUNTIME
74
 
// is best when you only have a small number of message types linked
75
 
// into your binary, in which case the size of the protocol buffers
76
 
// runtime itself is the biggest problem.
77
 
class LIBPROTOBUF_EXPORT MessageLite {
78
 
 public:
79
 
  inline MessageLite() {}
80
 
  virtual ~MessageLite();
81
 
 
82
 
  // Basic Operations ------------------------------------------------
83
 
 
84
 
  // Get the name of this message type, e.g. "foo.bar.BazProto".
85
 
  virtual string GetTypeName() const = 0;
86
 
 
87
 
  // Construct a new instance of the same type.  Ownership is passed to the
88
 
  // caller.
89
 
  virtual MessageLite* New() const = 0;
90
 
 
91
 
  // Clear all fields of the message and set them to their default values.
92
 
  // Clear() avoids freeing memory, assuming that any memory allocated
93
 
  // to hold parts of the message will be needed again to hold the next
94
 
  // message.  If you actually want to free the memory used by a Message,
95
 
  // you must delete it.
96
 
  virtual void Clear() = 0;
97
 
 
98
 
  // Quickly check if all required fields have values set.
99
 
  virtual bool IsInitialized() const = 0;
100
 
 
101
 
  // This is not implemented for Lite messages -- it just returns "(cannot
102
 
  // determine missing fields for lite message)".  However, it is implemented
103
 
  // for full messages.  See message.h.
104
 
  virtual string InitializationErrorString() const;
105
 
 
106
 
  // If |other| is the exact same class as this, calls MergeFrom().  Otherwise,
107
 
  // results are undefined (probably crash).
108
 
  virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0;
109
 
 
110
 
  // Parsing ---------------------------------------------------------
111
 
  // Methods for parsing in protocol buffer format.  Most of these are
112
 
  // just simple wrappers around MergeFromCodedStream().
113
 
 
114
 
  // Fill the message with a protocol buffer parsed from the given input
115
 
  // stream.  Returns false on a read error or if the input is in the
116
 
  // wrong format.
117
 
  bool ParseFromCodedStream(io::CodedInputStream* input);
118
 
  // Like ParseFromCodedStream(), but accepts messages that are missing
119
 
  // required fields.
120
 
  bool ParsePartialFromCodedStream(io::CodedInputStream* input);
121
 
  // Read a protocol buffer from the given zero-copy input stream.  If
122
 
  // successful, the entire input will be consumed.
123
 
  bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
124
 
  // Like ParseFromZeroCopyStream(), but accepts messages that are missing
125
 
  // required fields.
126
 
  bool ParsePartialFromZeroCopyStream(io::ZeroCopyInputStream* input);
127
 
  // Read a protocol buffer from the given zero-copy input stream, expecting
128
 
  // the message to be exactly "size" bytes long.  If successful, exactly
129
 
  // this many bytes will have been consumed from the input.
130
 
  bool ParseFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
131
 
  // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
132
 
  // missing required fields.
133
 
  bool ParsePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
134
 
                                             int size);
135
 
  // Parse a protocol buffer contained in a string.
136
 
  bool ParseFromString(const string& data);
137
 
  // Like ParseFromString(), but accepts messages that are missing
138
 
  // required fields.
139
 
  bool ParsePartialFromString(const string& data);
140
 
  // Parse a protocol buffer contained in an array of bytes.
141
 
  bool ParseFromArray(const void* data, int size);
142
 
  // Like ParseFromArray(), but accepts messages that are missing
143
 
  // required fields.
144
 
  bool ParsePartialFromArray(const void* data, int size);
145
 
 
146
 
 
147
 
  // Reads a protocol buffer from the stream and merges it into this
148
 
  // Message.  Singular fields read from the input overwrite what is
149
 
  // already in the Message and repeated fields are appended to those
150
 
  // already present.
151
 
  //
152
 
  // It is the responsibility of the caller to call input->LastTagWas()
153
 
  // (for groups) or input->ConsumedEntireMessage() (for non-groups) after
154
 
  // this returns to verify that the message's end was delimited correctly.
155
 
  //
156
 
  // ParsefromCodedStream() is implemented as Clear() followed by
157
 
  // MergeFromCodedStream().
158
 
  bool MergeFromCodedStream(io::CodedInputStream* input);
159
 
 
160
 
  // Like MergeFromCodedStream(), but succeeds even if required fields are
161
 
  // missing in the input.
162
 
  //
163
 
  // MergeFromCodedStream() is just implemented as MergePartialFromCodedStream()
164
 
  // followed by IsInitialized().
165
 
  virtual bool MergePartialFromCodedStream(io::CodedInputStream* input) = 0;
166
 
 
167
 
 
168
 
  // Serialization ---------------------------------------------------
169
 
  // Methods for serializing in protocol buffer format.  Most of these
170
 
  // are just simple wrappers around ByteSize() and SerializeWithCachedSizes().
171
 
 
172
 
  // Write a protocol buffer of this message to the given output.  Returns
173
 
  // false on a write error.  If the message is missing required fields,
174
 
  // this may GOOGLE_CHECK-fail.
175
 
  bool SerializeToCodedStream(io::CodedOutputStream* output) const;
176
 
  // Like SerializeToCodedStream(), but allows missing required fields.
177
 
  bool SerializePartialToCodedStream(io::CodedOutputStream* output) const;
178
 
  // Write the message to the given zero-copy output stream.  All required
179
 
  // fields must be set.
180
 
  bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
181
 
  // Like SerializeToZeroCopyStream(), but allows missing required fields.
182
 
  bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
183
 
  // Serialize the message and store it in the given string.  All required
184
 
  // fields must be set.
185
 
  bool SerializeToString(string* output) const;
186
 
  // Like SerializeToString(), but allows missing required fields.
187
 
  bool SerializePartialToString(string* output) const;
188
 
  // Serialize the message and store it in the given byte array.  All required
189
 
  // fields must be set.
190
 
  bool SerializeToArray(void* data, int size) const;
191
 
  // Like SerializeToArray(), but allows missing required fields.
192
 
  bool SerializePartialToArray(void* data, int size) const;
193
 
 
194
 
  // Make a string encoding the message. Is equivalent to calling
195
 
  // SerializeToString() on a string and using that.  Returns the empty
196
 
  // string if SerializeToString() would have returned an error.
197
 
  // Note: If you intend to generate many such strings, you may
198
 
  // reduce heap fragmentation by instead re-using the same string
199
 
  // object with calls to SerializeToString().
200
 
  string SerializeAsString() const;
201
 
  // Like SerializeAsString(), but allows missing required fields.
202
 
  string SerializePartialAsString() const;
203
 
 
204
 
  // Like SerializeToString(), but appends to the data to the string's existing
205
 
  // contents.  All required fields must be set.
206
 
  bool AppendToString(string* output) const;
207
 
  // Like AppendToString(), but allows missing required fields.
208
 
  bool AppendPartialToString(string* output) const;
209
 
 
210
 
  // Computes the serialized size of the message.  This recursively calls
211
 
  // ByteSize() on all embedded messages.  If a subclass does not override
212
 
  // this, it MUST override SetCachedSize().
213
 
  virtual int ByteSize() const = 0;
214
 
 
215
 
  // Serializes the message without recomputing the size.  The message must
216
 
  // not have changed since the last call to ByteSize(); if it has, the results
217
 
  // are undefined.
218
 
  virtual void SerializeWithCachedSizes(
219
 
      io::CodedOutputStream* output) const = 0;
220
 
 
221
 
  // Like SerializeWithCachedSizes, but writes directly to *target, returning
222
 
  // a pointer to the byte immediately after the last byte written.  "target"
223
 
  // must point at a byte array of at least ByteSize() bytes.
224
 
  virtual uint8* SerializeWithCachedSizesToArray(uint8* target) const;
225
 
 
226
 
  // Returns the result of the last call to ByteSize().  An embedded message's
227
 
  // size is needed both to serialize it (because embedded messages are
228
 
  // length-delimited) and to compute the outer message's size.  Caching
229
 
  // the size avoids computing it multiple times.
230
 
  //
231
 
  // ByteSize() does not automatically use the cached size when available
232
 
  // because this would require invalidating it every time the message was
233
 
  // modified, which would be too hard and expensive.  (E.g. if a deeply-nested
234
 
  // sub-message is changed, all of its parents' cached sizes would need to be
235
 
  // invalidated, which is too much work for an otherwise inlined setter
236
 
  // method.)
237
 
  virtual int GetCachedSize() const = 0;
238
 
 
239
 
 private:
240
 
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite);
241
 
};
242
 
 
243
 
}  // namespace protobuf
244
 
 
245
 
}  // namespace google
246
 
#endif  // GOOGLE_PROTOBUF_MESSAGE_LITE_H__