1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc. All rights reserved.
3// https://developers.google.com/protocol-buffers/
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: [email protected] (Kenton Varda)
32// Based on original Protocol Buffers design by
33// Sanjay Ghemawat, Jeff Dean, and others.
34//
35// This file contains the CodedInputStream and CodedOutputStream classes,
36// which wrap a ZeroCopyInputStream or ZeroCopyOutputStream, respectively,
37// and allow you to read or write individual pieces of data in various
38// formats. In particular, these implement the varint encoding for
39// integers, a simple variable-length encoding in which smaller numbers
40// take fewer bytes.
41//
42// Typically these classes will only be used internally by the protocol
43// buffer library in order to encode and decode protocol buffers. Clients
44// of the library only need to know about this class if they wish to write
45// custom message parsing or serialization procedures.
46//
47// CodedOutputStream example:
48// // Write some data to "myfile". First we write a 4-byte "magic number"
49// // to identify the file type, then write a length-delimited string. The
50// // string is composed of a varint giving the length followed by the raw
51// // bytes.
52// int fd = open("myfile", O_WRONLY);
53// ZeroCopyOutputStream* raw_output = new FileOutputStream(fd);
54// CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
55//
56// int magic_number = 1234;
57// char text[] = "Hello world!";
58// coded_output->WriteLittleEndian32(magic_number);
59// coded_output->WriteVarint32(strlen(text));
60// coded_output->WriteRaw(text, strlen(text));
61//
62// delete coded_output;
63// delete raw_output;
64// close(fd);
65//
66// CodedInputStream example:
67// // Read a file created by the above code.
68// int fd = open("myfile", O_RDONLY);
69// ZeroCopyInputStream* raw_input = new FileInputStream(fd);
70// CodedInputStream coded_input = new CodedInputStream(raw_input);
71//
72// coded_input->ReadLittleEndian32(&magic_number);
73// if (magic_number != 1234) {
74// cerr << "File not in expected format." << endl;
75// return;
76// }
77//
78// uint32 size;
79// coded_input->ReadVarint32(&size);
80//
81// char* text = new char[size + 1];
82// coded_input->ReadRaw(buffer, size);
83// text[size] = '\0';
84//
85// delete coded_input;
86// delete raw_input;
87// close(fd);
88//
89// cout << "Text is: " << text << endl;
90// delete [] text;
91//
92// For those who are interested, varint encoding is defined as follows:
93//
94// The encoding operates on unsigned integers of up to 64 bits in length.
95// Each byte of the encoded value has the format:
96// * bits 0-6: Seven bits of the number being encoded.
97// * bit 7: Zero if this is the last byte in the encoding (in which
98// case all remaining bits of the number are zero) or 1 if
99// more bytes follow.
100// The first byte contains the least-significant 7 bits of the number, the
101// second byte (if present) contains the next-least-significant 7 bits,
102// and so on. So, the binary number 1011000101011 would be encoded in two
103// bytes as "10101011 00101100".
104//
105// In theory, varint could be used to encode integers of any length.
106// However, for practicality we set a limit at 64 bits. The maximum encoded
107// length of a number is thus 10 bytes.
108
109#ifndef GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
110#define GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
111
112#include <string>
113#ifdef _MSC_VER
114 #if defined(_M_IX86) && \
115 !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
116 #define PROTOBUF_LITTLE_ENDIAN 1
117 #endif
118 #if _MSC_VER >= 1300
119 // If MSVC has "/RTCc" set, it will complain about truncating casts at
120 // runtime. This file contains some intentional truncating casts.
121 #pragma runtime_checks("c", off)
122 #endif
123#else
124 #include <sys/param.h> // __BYTE_ORDER
125 #if defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN && \
126 !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
127 #define PROTOBUF_LITTLE_ENDIAN 1
128 #endif
129#endif
130#include <google/protobuf/stubs/common.h>
131
132
133namespace google {
134namespace protobuf {
135
136class DescriptorPool;
137class MessageFactory;
138
139namespace io {
140
141// Defined in this file.
142class CodedInputStream;
143class CodedOutputStream;
144
145// Defined in other files.
146class ZeroCopyInputStream; // zero_copy_stream.h
147class ZeroCopyOutputStream; // zero_copy_stream.h
148
149// Class which reads and decodes binary data which is composed of varint-
150// encoded integers and fixed-width pieces. Wraps a ZeroCopyInputStream.
151// Most users will not need to deal with CodedInputStream.
152//
153// Most methods of CodedInputStream that return a bool return false if an
154// underlying I/O error occurs or if the data is malformed. Once such a
155// failure occurs, the CodedInputStream is broken and is no longer useful.
156class LIBPROTOBUF_EXPORT CodedInputStream {
157 public:
158 // Create a CodedInputStream that reads from the given ZeroCopyInputStream.
159 explicit CodedInputStream(ZeroCopyInputStream* input);
160
161 // Create a CodedInputStream that reads from the given flat array. This is
162 // faster than using an ArrayInputStream. PushLimit(size) is implied by
163 // this constructor.
164 explicit CodedInputStream(const uint8* buffer, int size);
165
166 // Destroy the CodedInputStream and position the underlying
167 // ZeroCopyInputStream at the first unread byte. If an error occurred while
168 // reading (causing a method to return false), then the exact position of
169 // the input stream may be anywhere between the last value that was read
170 // successfully and the stream's byte limit.
171 ~CodedInputStream();
172
173 // Return true if this CodedInputStream reads from a flat array instead of
174 // a ZeroCopyInputStream.
175 inline bool IsFlat() const;
176
177 // Skips a number of bytes. Returns false if an underlying read error
178 // occurs.
179 bool Skip(int count);
180
181 // Sets *data to point directly at the unread part of the CodedInputStream's
182 // underlying buffer, and *size to the size of that buffer, but does not
183 // advance the stream's current position. This will always either produce
184 // a non-empty buffer or return false. If the caller consumes any of
185 // this data, it should then call Skip() to skip over the consumed bytes.
186 // This may be useful for implementing external fast parsing routines for
187 // types of data not covered by the CodedInputStream interface.
188 bool GetDirectBufferPointer(const void** data, int* size);
189
190 // Like GetDirectBufferPointer, but this method is inlined, and does not
191 // attempt to Refresh() if the buffer is currently empty.
192 inline void GetDirectBufferPointerInline(const void** data,
193 int* size) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
194
195 // Read raw bytes, copying them into the given buffer.
196 bool ReadRaw(void* buffer, int size);
197
198 // Like ReadRaw, but reads into a string.
199 //
200 // Implementation Note: ReadString() grows the string gradually as it
201 // reads in the data, rather than allocating the entire requested size
202 // upfront. This prevents denial-of-service attacks in which a client
203 // could claim that a string is going to be MAX_INT bytes long in order to
204 // crash the server because it can't allocate this much space at once.
205 bool ReadString(string* buffer, int size);
206 // Like the above, with inlined optimizations. This should only be used
207 // by the protobuf implementation.
208 inline bool InternalReadStringInline(string* buffer,
209 int size) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
210
211
212 // Read a 32-bit little-endian integer.
213 bool ReadLittleEndian32(uint32* value);
214 // Read a 64-bit little-endian integer.
215 bool ReadLittleEndian64(uint64* value);
216
217 // These methods read from an externally provided buffer. The caller is
218 // responsible for ensuring that the buffer has sufficient space.
219 // Read a 32-bit little-endian integer.
220 static const uint8* ReadLittleEndian32FromArray(const uint8* buffer,
221 uint32* value);
222 // Read a 64-bit little-endian integer.
223 static const uint8* ReadLittleEndian64FromArray(const uint8* buffer,
224 uint64* value);
225
226 // Read an unsigned integer with Varint encoding, truncating to 32 bits.
227 // Reading a 32-bit value is equivalent to reading a 64-bit one and casting
228 // it to uint32, but may be more efficient.
229 bool ReadVarint32(uint32* value);
230 // Read an unsigned integer with Varint encoding.
231 bool ReadVarint64(uint64* value);
232
233 // Read a tag. This calls ReadVarint32() and returns the result, or returns
234 // zero (which is not a valid tag) if ReadVarint32() fails. Also, it updates
235 // the last tag value, which can be checked with LastTagWas().
236 // Always inline because this is only called in one place per parse loop
237 // but it is called for every iteration of said loop, so it should be fast.
238 // GCC doesn't want to inline this by default.
239 uint32 ReadTag() GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
240
241 // This usually a faster alternative to ReadTag() when cutoff is a manifest
242 // constant. It does particularly well for cutoff >= 127. The first part
243 // of the return value is the tag that was read, though it can also be 0 in
244 // the cases where ReadTag() would return 0. If the second part is true
245 // then the tag is known to be in [0, cutoff]. If not, the tag either is
246 // above cutoff or is 0. (There's intentional wiggle room when tag is 0,
247 // because that can arise in several ways, and for best performance we want
248 // to avoid an extra "is tag == 0?" check here.)
249 inline std::pair<uint32, bool> ReadTagWithCutoff(uint32 cutoff)
250 GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
251
252 // Usually returns true if calling ReadVarint32() now would produce the given
253 // value. Will always return false if ReadVarint32() would not return the
254 // given value. If ExpectTag() returns true, it also advances past
255 // the varint. For best performance, use a compile-time constant as the
256 // parameter.
257 // Always inline because this collapses to a small number of instructions
258 // when given a constant parameter, but GCC doesn't want to inline by default.
259 bool ExpectTag(uint32 expected) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
260
261 // Like above, except this reads from the specified buffer. The caller is
262 // responsible for ensuring that the buffer is large enough to read a varint
263 // of the expected size. For best performance, use a compile-time constant as
264 // the expected tag parameter.
265 //
266 // Returns a pointer beyond the expected tag if it was found, or NULL if it
267 // was not.
268 static const uint8* ExpectTagFromArray(
269 const uint8* buffer,
270 uint32 expected) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
271
272 // Usually returns true if no more bytes can be read. Always returns false
273 // if more bytes can be read. If ExpectAtEnd() returns true, a subsequent
274 // call to LastTagWas() will act as if ReadTag() had been called and returned
275 // zero, and ConsumedEntireMessage() will return true.
276 bool ExpectAtEnd();
277
278 // If the last call to ReadTag() or ReadTagWithCutoff() returned the
279 // given value, returns true. Otherwise, returns false;
280 //
281 // This is needed because parsers for some types of embedded messages
282 // (with field type TYPE_GROUP) don't actually know that they've reached the
283 // end of a message until they see an ENDGROUP tag, which was actually part
284 // of the enclosing message. The enclosing message would like to check that
285 // tag to make sure it had the right number, so it calls LastTagWas() on
286 // return from the embedded parser to check.
287 bool LastTagWas(uint32 expected);
288
289 // When parsing message (but NOT a group), this method must be called
290 // immediately after MergeFromCodedStream() returns (if it returns true)
291 // to further verify that the message ended in a legitimate way. For
292 // example, this verifies that parsing did not end on an end-group tag.
293 // It also checks for some cases where, due to optimizations,
294 // MergeFromCodedStream() can incorrectly return true.
295 bool ConsumedEntireMessage();
296
297 // Limits ----------------------------------------------------------
298 // Limits are used when parsing length-delimited embedded messages.
299 // After the message's length is read, PushLimit() is used to prevent
300 // the CodedInputStream from reading beyond that length. Once the
301 // embedded message has been parsed, PopLimit() is called to undo the
302 // limit.
303
304 // Opaque type used with PushLimit() and PopLimit(). Do not modify
305 // values of this type yourself. The only reason that this isn't a
306 // struct with private internals is for efficiency.
307 typedef int Limit;
308
309 // Places a limit on the number of bytes that the stream may read,
310 // starting from the current position. Once the stream hits this limit,
311 // it will act like the end of the input has been reached until PopLimit()
312 // is called.
313 //
314 // As the names imply, the stream conceptually has a stack of limits. The
315 // shortest limit on the stack is always enforced, even if it is not the
316 // top limit.
317 //
318 // The value returned by PushLimit() is opaque to the caller, and must
319 // be passed unchanged to the corresponding call to PopLimit().
320 Limit PushLimit(int byte_limit);
321
322 // Pops the last limit pushed by PushLimit(). The input must be the value
323 // returned by that call to PushLimit().
324 void PopLimit(Limit limit);
325
326 // Returns the number of bytes left until the nearest limit on the
327 // stack is hit, or -1 if no limits are in place.
328 int BytesUntilLimit() const;
329
330 // Returns current position relative to the beginning of the input stream.
331 int CurrentPosition() const;
332
333 // Total Bytes Limit -----------------------------------------------
334 // To prevent malicious users from sending excessively large messages
335 // and causing integer overflows or memory exhaustion, CodedInputStream
336 // imposes a hard limit on the total number of bytes it will read.
337
338 // Sets the maximum number of bytes that this CodedInputStream will read
339 // before refusing to continue. To prevent integer overflows in the
340 // protocol buffers implementation, as well as to prevent servers from
341 // allocating enormous amounts of memory to hold parsed messages, the
342 // maximum message length should be limited to the shortest length that
343 // will not harm usability. The theoretical shortest message that could
344 // cause integer overflows is 512MB. The default limit is 64MB. Apps
345 // should set shorter limits if possible. If warning_threshold is not -1,
346 // a warning will be printed to stderr after warning_threshold bytes are
347 // read. For backwards compatibility all negative values get squashed to -1,
348 // as other negative values might have special internal meanings.
349 // An error will always be printed to stderr if the limit is reached.
350 //
351 // This is unrelated to PushLimit()/PopLimit().
352 //
353 // Hint: If you are reading this because your program is printing a
354 // warning about dangerously large protocol messages, you may be
355 // confused about what to do next. The best option is to change your
356 // design such that excessively large messages are not necessary.
357 // For example, try to design file formats to consist of many small
358 // messages rather than a single large one. If this is infeasible,
359 // you will need to increase the limit. Chances are, though, that
360 // your code never constructs a CodedInputStream on which the limit
361 // can be set. You probably parse messages by calling things like
362 // Message::ParseFromString(). In this case, you will need to change
363 // your code to instead construct some sort of ZeroCopyInputStream
364 // (e.g. an ArrayInputStream), construct a CodedInputStream around
365 // that, then call Message::ParseFromCodedStream() instead. Then
366 // you can adjust the limit. Yes, it's more work, but you're doing
367 // something unusual.
368 void SetTotalBytesLimit(int total_bytes_limit, int warning_threshold);
369
370 // The Total Bytes Limit minus the Current Position, or -1 if there
371 // is no Total Bytes Limit.
372 int BytesUntilTotalBytesLimit() const;
373
374 // Recursion Limit -------------------------------------------------
375 // To prevent corrupt or malicious messages from causing stack overflows,
376 // we must keep track of the depth of recursion when parsing embedded
377 // messages and groups. CodedInputStream keeps track of this because it
378 // is the only object that is passed down the stack during parsing.
379
380 // Sets the maximum recursion depth. The default is 100.
381 void SetRecursionLimit(int limit);
382
383
384 // Increments the current recursion depth. Returns true if the depth is
385 // under the limit, false if it has gone over.
386 bool IncrementRecursionDepth();
387
388 // Decrements the recursion depth.
389 void DecrementRecursionDepth();
390
391 // Extension Registry ----------------------------------------------
392 // ADVANCED USAGE: 99.9% of people can ignore this section.
393 //
394 // By default, when parsing extensions, the parser looks for extension
395 // definitions in the pool which owns the outer message's Descriptor.
396 // However, you may call SetExtensionRegistry() to provide an alternative
397 // pool instead. This makes it possible, for example, to parse a message
398 // using a generated class, but represent some extensions using
399 // DynamicMessage.
400
401 // Set the pool used to look up extensions. Most users do not need to call
402 // this as the correct pool will be chosen automatically.
403 //
404 // WARNING: It is very easy to misuse this. Carefully read the requirements
405 // below. Do not use this unless you are sure you need it. Almost no one
406 // does.
407 //
408 // Let's say you are parsing a message into message object m, and you want
409 // to take advantage of SetExtensionRegistry(). You must follow these
410 // requirements:
411 //
412 // The given DescriptorPool must contain m->GetDescriptor(). It is not
413 // sufficient for it to simply contain a descriptor that has the same name
414 // and content -- it must be the *exact object*. In other words:
415 // assert(pool->FindMessageTypeByName(m->GetDescriptor()->full_name()) ==
416 // m->GetDescriptor());
417 // There are two ways to satisfy this requirement:
418 // 1) Use m->GetDescriptor()->pool() as the pool. This is generally useless
419 // because this is the pool that would be used anyway if you didn't call
420 // SetExtensionRegistry() at all.
421 // 2) Use a DescriptorPool which has m->GetDescriptor()->pool() as an
422 // "underlay". Read the documentation for DescriptorPool for more
423 // information about underlays.
424 //
425 // You must also provide a MessageFactory. This factory will be used to
426 // construct Message objects representing extensions. The factory's
427 // GetPrototype() MUST return non-NULL for any Descriptor which can be found
428 // through the provided pool.
429 //
430 // If the provided factory might return instances of protocol-compiler-
431 // generated (i.e. compiled-in) types, or if the outer message object m is
432 // a generated type, then the given factory MUST have this property: If
433 // GetPrototype() is given a Descriptor which resides in
434 // DescriptorPool::generated_pool(), the factory MUST return the same
435 // prototype which MessageFactory::generated_factory() would return. That
436 // is, given a descriptor for a generated type, the factory must return an
437 // instance of the generated class (NOT DynamicMessage). However, when
438 // given a descriptor for a type that is NOT in generated_pool, the factory
439 // is free to return any implementation.
440 //
441 // The reason for this requirement is that generated sub-objects may be
442 // accessed via the standard (non-reflection) extension accessor methods,
443 // and these methods will down-cast the object to the generated class type.
444 // If the object is not actually of that type, the results would be undefined.
445 // On the other hand, if an extension is not compiled in, then there is no
446 // way the code could end up accessing it via the standard accessors -- the
447 // only way to access the extension is via reflection. When using reflection,
448 // DynamicMessage and generated messages are indistinguishable, so it's fine
449 // if these objects are represented using DynamicMessage.
450 //
451 // Using DynamicMessageFactory on which you have called
452 // SetDelegateToGeneratedFactory(true) should be sufficient to satisfy the
453 // above requirement.
454 //
455 // If either pool or factory is NULL, both must be NULL.
456 //
457 // Note that this feature is ignored when parsing "lite" messages as they do
458 // not have descriptors.
459 void SetExtensionRegistry(const DescriptorPool* pool,
460 MessageFactory* factory);
461
462 // Get the DescriptorPool set via SetExtensionRegistry(), or NULL if no pool
463 // has been provided.
464 const DescriptorPool* GetExtensionPool();
465
466 // Get the MessageFactory set via SetExtensionRegistry(), or NULL if no
467 // factory has been provided.
468 MessageFactory* GetExtensionFactory();
469
470 private:
471 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedInputStream);
472
473 ZeroCopyInputStream* input_;
474 const uint8* buffer_;
475 const uint8* buffer_end_; // pointer to the end of the buffer.
476 int total_bytes_read_; // total bytes read from input_, including
477 // the current buffer
478
479 // If total_bytes_read_ surpasses INT_MAX, we record the extra bytes here
480 // so that we can BackUp() on destruction.
481 int overflow_bytes_;
482
483 // LastTagWas() stuff.
484 uint32 last_tag_; // result of last ReadTag() or ReadTagWithCutoff().
485
486 // This is set true by ReadTag{Fallback/Slow}() if it is called when exactly
487 // at EOF, or by ExpectAtEnd() when it returns true. This happens when we
488 // reach the end of a message and attempt to read another tag.
489 bool legitimate_message_end_;
490
491 // See EnableAliasing().
492 bool aliasing_enabled_;
493
494 // Limits
495 Limit current_limit_; // if position = -1, no limit is applied
496
497 // For simplicity, if the current buffer crosses a limit (either a normal
498 // limit created by PushLimit() or the total bytes limit), buffer_size_
499 // only tracks the number of bytes before that limit. This field
500 // contains the number of bytes after it. Note that this implies that if
501 // buffer_size_ == 0 and buffer_size_after_limit_ > 0, we know we've
502 // hit a limit. However, if both are zero, it doesn't necessarily mean
503 // we aren't at a limit -- the buffer may have ended exactly at the limit.
504 int buffer_size_after_limit_;
505
506 // Maximum number of bytes to read, period. This is unrelated to
507 // current_limit_. Set using SetTotalBytesLimit().
508 int total_bytes_limit_;
509
510 // If positive/0: Limit for bytes read after which a warning due to size
511 // should be logged.
512 // If -1: Printing of warning disabled. Can be set by client.
513 // If -2: Internal: Limit has been reached, print full size when destructing.
514 int total_bytes_warning_threshold_;
515
516 // Current recursion depth, controlled by IncrementRecursionDepth() and
517 // DecrementRecursionDepth().
518 int recursion_depth_;
519 // Recursion depth limit, set by SetRecursionLimit().
520 int recursion_limit_;
521
522 // See SetExtensionRegistry().
523 const DescriptorPool* extension_pool_;
524 MessageFactory* extension_factory_;
525
526 // Private member functions.
527
528 // Advance the buffer by a given number of bytes.
529 void Advance(int amount);
530
531 // Back up input_ to the current buffer position.
532 void BackUpInputToCurrentPosition();
533
534 // Recomputes the value of buffer_size_after_limit_. Must be called after
535 // current_limit_ or total_bytes_limit_ changes.
536 void RecomputeBufferLimits();
537
538 // Writes an error message saying that we hit total_bytes_limit_.
539 void PrintTotalBytesLimitError();
540
541 // Called when the buffer runs out to request more data. Implies an
542 // Advance(BufferSize()).
543 bool Refresh();
544
545 // When parsing varints, we optimize for the common case of small values, and
546 // then optimize for the case when the varint fits within the current buffer
547 // piece. The Fallback method is used when we can't use the one-byte
548 // optimization. The Slow method is yet another fallback when the buffer is
549 // not large enough. Making the slow path out-of-line speeds up the common
550 // case by 10-15%. The slow path is fairly uncommon: it only triggers when a
551 // message crosses multiple buffers.
552 bool ReadVarint32Fallback(uint32* value);
553 bool ReadVarint64Fallback(uint64* value);
554 bool ReadVarint32Slow(uint32* value);
555 bool ReadVarint64Slow(uint64* value);
556 bool ReadLittleEndian32Fallback(uint32* value);
557 bool ReadLittleEndian64Fallback(uint64* value);
558 // Fallback/slow methods for reading tags. These do not update last_tag_,
559 // but will set legitimate_message_end_ if we are at the end of the input
560 // stream.
561 uint32 ReadTagFallback();
562 uint32 ReadTagSlow();
563 bool ReadStringFallback(string* buffer, int size);
564
565 // Return the size of the buffer.
566 int BufferSize() const;
567
568 static const int kDefaultTotalBytesLimit = 64 << 20; // 64MB
569
570 static const int kDefaultTotalBytesWarningThreshold = 32 << 20; // 32MB
571
572 static int default_recursion_limit_; // 100 by default.
573};
574
575// Class which encodes and writes binary data which is composed of varint-
576// encoded integers and fixed-width pieces. Wraps a ZeroCopyOutputStream.
577// Most users will not need to deal with CodedOutputStream.
578//
579// Most methods of CodedOutputStream which return a bool return false if an
580// underlying I/O error occurs. Once such a failure occurs, the
581// CodedOutputStream is broken and is no longer useful. The Write* methods do
582// not return the stream status, but will invalidate the stream if an error
583// occurs. The client can probe HadError() to determine the status.
584//
585// Note that every method of CodedOutputStream which writes some data has
586// a corresponding static "ToArray" version. These versions write directly
587// to the provided buffer, returning a pointer past the last written byte.
588// They require that the buffer has sufficient capacity for the encoded data.
589// This allows an optimization where we check if an output stream has enough
590// space for an entire message before we start writing and, if there is, we
591// call only the ToArray methods to avoid doing bound checks for each
592// individual value.
593// i.e., in the example above:
594//
595// CodedOutputStream coded_output = new CodedOutputStream(raw_output);
596// int magic_number = 1234;
597// char text[] = "Hello world!";
598//
599// int coded_size = sizeof(magic_number) +
600// CodedOutputStream::VarintSize32(strlen(text)) +
601// strlen(text);
602//
603// uint8* buffer =
604// coded_output->GetDirectBufferForNBytesAndAdvance(coded_size);
605// if (buffer != NULL) {
606// // The output stream has enough space in the buffer: write directly to
607// // the array.
608// buffer = CodedOutputStream::WriteLittleEndian32ToArray(magic_number,
609// buffer);
610// buffer = CodedOutputStream::WriteVarint32ToArray(strlen(text), buffer);
611// buffer = CodedOutputStream::WriteRawToArray(text, strlen(text), buffer);
612// } else {
613// // Make bound-checked writes, which will ask the underlying stream for
614// // more space as needed.
615// coded_output->WriteLittleEndian32(magic_number);
616// coded_output->WriteVarint32(strlen(text));
617// coded_output->WriteRaw(text, strlen(text));
618// }
619//
620// delete coded_output;
621class LIBPROTOBUF_EXPORT CodedOutputStream {
622 public:
623 // Create an CodedOutputStream that writes to the given ZeroCopyOutputStream.
624 explicit CodedOutputStream(ZeroCopyOutputStream* output);
625
626 // Destroy the CodedOutputStream and position the underlying
627 // ZeroCopyOutputStream immediately after the last byte written.
628 ~CodedOutputStream();
629
630 // Skips a number of bytes, leaving the bytes unmodified in the underlying
631 // buffer. Returns false if an underlying write error occurs. This is
632 // mainly useful with GetDirectBufferPointer().
633 bool Skip(int count);
634
635 // Sets *data to point directly at the unwritten part of the
636 // CodedOutputStream's underlying buffer, and *size to the size of that
637 // buffer, but does not advance the stream's current position. This will
638 // always either produce a non-empty buffer or return false. If the caller
639 // writes any data to this buffer, it should then call Skip() to skip over
640 // the consumed bytes. This may be useful for implementing external fast
641 // serialization routines for types of data not covered by the
642 // CodedOutputStream interface.
643 bool GetDirectBufferPointer(void** data, int* size);
644
645 // If there are at least "size" bytes available in the current buffer,
646 // returns a pointer directly into the buffer and advances over these bytes.
647 // The caller may then write directly into this buffer (e.g. using the
648 // *ToArray static methods) rather than go through CodedOutputStream. If
649 // there are not enough bytes available, returns NULL. The return pointer is
650 // invalidated as soon as any other non-const method of CodedOutputStream
651 // is called.
652 inline uint8* GetDirectBufferForNBytesAndAdvance(int size);
653
654 // Write raw bytes, copying them from the given buffer.
655 void WriteRaw(const void* buffer, int size);
656 // Like WriteRaw() but will try to write aliased data if aliasing is
657 // turned on.
658 void WriteRawMaybeAliased(const void* data, int size);
659 // Like WriteRaw() but writing directly to the target array.
660 // This is _not_ inlined, as the compiler often optimizes memcpy into inline
661 // copy loops. Since this gets called by every field with string or bytes
662 // type, inlining may lead to a significant amount of code bloat, with only a
663 // minor performance gain.
664 static uint8* WriteRawToArray(const void* buffer, int size, uint8* target);
665
666 // Equivalent to WriteRaw(str.data(), str.size()).
667 void WriteString(const string& str);
668 // Like WriteString() but writing directly to the target array.
669 static uint8* WriteStringToArray(const string& str, uint8* target);
670 // Write the varint-encoded size of str followed by str.
671 static uint8* WriteStringWithSizeToArray(const string& str, uint8* target);
672
673
674 // Instructs the CodedOutputStream to allow the underlying
675 // ZeroCopyOutputStream to hold pointers to the original structure instead of
676 // copying, if it supports it (i.e. output->AllowsAliasing() is true). If the
677 // underlying stream does not support aliasing, then enabling it has no
678 // affect. For now, this only affects the behavior of
679 // WriteRawMaybeAliased().
680 //
681 // NOTE: It is caller's responsibility to ensure that the chunk of memory
682 // remains live until all of the data has been consumed from the stream.
683 void EnableAliasing(bool enabled);
684
685 // Write a 32-bit little-endian integer.
686 void WriteLittleEndian32(uint32 value);
687 // Like WriteLittleEndian32() but writing directly to the target array.
688 static uint8* WriteLittleEndian32ToArray(uint32 value, uint8* target);
689 // Write a 64-bit little-endian integer.
690 void WriteLittleEndian64(uint64 value);
691 // Like WriteLittleEndian64() but writing directly to the target array.
692 static uint8* WriteLittleEndian64ToArray(uint64 value, uint8* target);
693
694 // Write an unsigned integer with Varint encoding. Writing a 32-bit value
695 // is equivalent to casting it to uint64 and writing it as a 64-bit value,
696 // but may be more efficient.
697 void WriteVarint32(uint32 value);
698 // Like WriteVarint32() but writing directly to the target array.
699 static uint8* WriteVarint32ToArray(uint32 value, uint8* target);
700 // Write an unsigned integer with Varint encoding.
701 void WriteVarint64(uint64 value);
702 // Like WriteVarint64() but writing directly to the target array.
703 static uint8* WriteVarint64ToArray(uint64 value, uint8* target);
704
705 // Equivalent to WriteVarint32() except when the value is negative,
706 // in which case it must be sign-extended to a full 10 bytes.
707 void WriteVarint32SignExtended(int32 value);
708 // Like WriteVarint32SignExtended() but writing directly to the target array.
709 static uint8* WriteVarint32SignExtendedToArray(int32 value, uint8* target);
710
711 // This is identical to WriteVarint32(), but optimized for writing tags.
712 // In particular, if the input is a compile-time constant, this method
713 // compiles down to a couple instructions.
714 // Always inline because otherwise the aformentioned optimization can't work,
715 // but GCC by default doesn't want to inline this.
716 void WriteTag(uint32 value);
717 // Like WriteTag() but writing directly to the target array.
718 static uint8* WriteTagToArray(
719 uint32 value, uint8* target) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
720
721 // Returns the number of bytes needed to encode the given value as a varint.
722 static int VarintSize32(uint32 value);
723 // Returns the number of bytes needed to encode the given value as a varint.
724 static int VarintSize64(uint64 value);
725
726 // If negative, 10 bytes. Otheriwse, same as VarintSize32().
727 static int VarintSize32SignExtended(int32 value);
728
729 // Compile-time equivalent of VarintSize32().
730 template <uint32 Value>
731 struct StaticVarintSize32 {
732 static const int value =
733 (Value < (1 << 7))
734 ? 1
735 : (Value < (1 << 14))
736 ? 2
737 : (Value < (1 << 21))
738 ? 3
739 : (Value < (1 << 28))
740 ? 4
741 : 5;
742 };
743
744 // Returns the total number of bytes written since this object was created.
745 inline int ByteCount() const;
746
747 // Returns true if there was an underlying I/O error since this object was
748 // created.
749 bool HadError() const { return had_error_; }
750
751 private:
752 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedOutputStream);
753
754 ZeroCopyOutputStream* output_;
755 uint8* buffer_;
756 int buffer_size_;
757 int total_bytes_; // Sum of sizes of all buffers seen so far.
758 bool had_error_; // Whether an error occurred during output.
759 bool aliasing_enabled_; // See EnableAliasing().
760
761 // Advance the buffer by a given number of bytes.
762 void Advance(int amount);
763
764 // Called when the buffer runs out to request more data. Implies an
765 // Advance(buffer_size_).
766 bool Refresh();
767
768 // Like WriteRaw() but may avoid copying if the underlying
769 // ZeroCopyOutputStream supports it.
770 void WriteAliasedRaw(const void* buffer, int size);
771
772 static uint8* WriteVarint32FallbackToArray(uint32 value, uint8* target);
773
774 // Always-inlined versions of WriteVarint* functions so that code can be
775 // reused, while still controlling size. For instance, WriteVarint32ToArray()
776 // should not directly call this: since it is inlined itself, doing so
777 // would greatly increase the size of generated code. Instead, it should call
778 // WriteVarint32FallbackToArray. Meanwhile, WriteVarint32() is already
779 // out-of-line, so it should just invoke this directly to avoid any extra
780 // function call overhead.
781 static uint8* WriteVarint32FallbackToArrayInline(
782 uint32 value, uint8* target) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
783 static uint8* WriteVarint64ToArrayInline(
784 uint64 value, uint8* target) GOOGLE_ATTRIBUTE_ALWAYS_INLINE;
785
786 static int VarintSize32Fallback(uint32 value);
787};
788
789// inline methods ====================================================
790// The vast majority of varints are only one byte. These inline
791// methods optimize for that case.
792
793inline bool CodedInputStream::ReadVarint32(uint32* value) {
794 if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
795 *value = *buffer_;
796 Advance(1);
797 return true;
798 } else {
799 return ReadVarint32Fallback(value);
800 }
801}
802
803inline bool CodedInputStream::ReadVarint64(uint64* value) {
804 if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
805 *value = *buffer_;
806 Advance(1);
807 return true;
808 } else {
809 return ReadVarint64Fallback(value);
810 }
811}
812
813// static
814inline const uint8* CodedInputStream::ReadLittleEndian32FromArray(
815 const uint8* buffer,
816 uint32* value) {
817#if defined(PROTOBUF_LITTLE_ENDIAN)
818 memcpy(value, buffer, sizeof(*value));
819 return buffer + sizeof(*value);
820#else
821 *value = (static_cast<uint32>(buffer[0]) ) |
822 (static_cast<uint32>(buffer[1]) << 8) |
823 (static_cast<uint32>(buffer[2]) << 16) |
824 (static_cast<uint32>(buffer[3]) << 24);
825 return buffer + sizeof(*value);
826#endif
827}
828// static
829inline const uint8* CodedInputStream::ReadLittleEndian64FromArray(
830 const uint8* buffer,
831 uint64* value) {
832#if defined(PROTOBUF_LITTLE_ENDIAN)
833 memcpy(value, buffer, sizeof(*value));
834 return buffer + sizeof(*value);
835#else
836 uint32 part0 = (static_cast<uint32>(buffer[0]) ) |
837 (static_cast<uint32>(buffer[1]) << 8) |
838 (static_cast<uint32>(buffer[2]) << 16) |
839 (static_cast<uint32>(buffer[3]) << 24);
840 uint32 part1 = (static_cast<uint32>(buffer[4]) ) |
841 (static_cast<uint32>(buffer[5]) << 8) |
842 (static_cast<uint32>(buffer[6]) << 16) |
843 (static_cast<uint32>(buffer[7]) << 24);
844 *value = static_cast<uint64>(part0) |
845 (static_cast<uint64>(part1) << 32);
846 return buffer + sizeof(*value);
847#endif
848}
849
850inline bool CodedInputStream::ReadLittleEndian32(uint32* value) {
851#if defined(PROTOBUF_LITTLE_ENDIAN)
852 if (GOOGLE_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
853 memcpy(value, buffer_, sizeof(*value));
854 Advance(sizeof(*value));
855 return true;
856 } else {
857 return ReadLittleEndian32Fallback(value);
858 }
859#else
860 return ReadLittleEndian32Fallback(value);
861#endif
862}
863
864inline bool CodedInputStream::ReadLittleEndian64(uint64* value) {
865#if defined(PROTOBUF_LITTLE_ENDIAN)
866 if (GOOGLE_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
867 memcpy(value, buffer_, sizeof(*value));
868 Advance(sizeof(*value));
869 return true;
870 } else {
871 return ReadLittleEndian64Fallback(value);
872 }
873#else
874 return ReadLittleEndian64Fallback(value);
875#endif
876}
877
878inline uint32 CodedInputStream::ReadTag() {
879 if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && buffer_[0] < 0x80) {
880 last_tag_ = buffer_[0];
881 Advance(1);
882 return last_tag_;
883 } else {
884 last_tag_ = ReadTagFallback();
885 return last_tag_;
886 }
887}
888
889inline std::pair<uint32, bool> CodedInputStream::ReadTagWithCutoff(
890 uint32 cutoff) {
891 // In performance-sensitive code we can expect cutoff to be a compile-time
892 // constant, and things like "cutoff >= kMax1ByteVarint" to be evaluated at
893 // compile time.
894 if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_)) {
895 // Hot case: buffer_ non_empty, buffer_[0] in [1, 128).
896 // TODO(gpike): Is it worth rearranging this? E.g., if the number of fields
897 // is large enough then is it better to check for the two-byte case first?
898 if (static_cast<int8>(buffer_[0]) > 0) {
899 const uint32 kMax1ByteVarint = 0x7f;
900 uint32 tag = last_tag_ = buffer_[0];
901 Advance(1);
902 return make_pair(tag, cutoff >= kMax1ByteVarint || tag <= cutoff);
903 }
904 // Other hot case: cutoff >= 0x80, buffer_ has at least two bytes available,
905 // and tag is two bytes. The latter is tested by bitwise-and-not of the
906 // first byte and the second byte.
907 if (cutoff >= 0x80 &&
908 GOOGLE_PREDICT_TRUE(buffer_ + 1 < buffer_end_) &&
909 GOOGLE_PREDICT_TRUE((buffer_[0] & ~buffer_[1]) >= 0x80)) {
910 const uint32 kMax2ByteVarint = (0x7f << 7) + 0x7f;
911 uint32 tag = last_tag_ = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
912 Advance(2);
913 // It might make sense to test for tag == 0 now, but it is so rare that
914 // that we don't bother. A varint-encoded 0 should be one byte unless
915 // the encoder lost its mind. The second part of the return value of
916 // this function is allowed to be either true or false if the tag is 0,
917 // so we don't have to check for tag == 0. We may need to check whether
918 // it exceeds cutoff.
919 bool at_or_below_cutoff = cutoff >= kMax2ByteVarint || tag <= cutoff;
920 return make_pair(tag, at_or_below_cutoff);
921 }
922 }
923 // Slow path
924 last_tag_ = ReadTagFallback();
925 return make_pair(last_tag_, static_cast<uint32>(last_tag_ - 1) < cutoff);
926}
927
928inline bool CodedInputStream::LastTagWas(uint32 expected) {
929 return last_tag_ == expected;
930}
931
932inline bool CodedInputStream::ConsumedEntireMessage() {
933 return legitimate_message_end_;
934}
935
936inline bool CodedInputStream::ExpectTag(uint32 expected) {
937 if (expected < (1 << 7)) {
938 if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && buffer_[0] == expected) {
939 Advance(1);
940 return true;
941 } else {
942 return false;
943 }
944 } else if (expected < (1 << 14)) {
945 if (GOOGLE_PREDICT_TRUE(BufferSize() >= 2) &&
946 buffer_[0] == static_cast<uint8>(expected | 0x80) &&
947 buffer_[1] == static_cast<uint8>(expected >> 7)) {
948 Advance(2);
949 return true;
950 } else {
951 return false;
952 }
953 } else {
954 // Don't bother optimizing for larger values.
955 return false;
956 }
957}
958
959inline const uint8* CodedInputStream::ExpectTagFromArray(
960 const uint8* buffer, uint32 expected) {
961 if (expected < (1 << 7)) {
962 if (buffer[0] == expected) {
963 return buffer + 1;
964 }
965 } else if (expected < (1 << 14)) {
966 if (buffer[0] == static_cast<uint8>(expected | 0x80) &&
967 buffer[1] == static_cast<uint8>(expected >> 7)) {
968 return buffer + 2;
969 }
970 }
971 return NULL;
972}
973
974inline void CodedInputStream::GetDirectBufferPointerInline(const void** data,
975 int* size) {
976 *data = buffer_;
977 *size = buffer_end_ - buffer_;
978}
979
980inline bool CodedInputStream::ExpectAtEnd() {
981 // If we are at a limit we know no more bytes can be read. Otherwise, it's
982 // hard to say without calling Refresh(), and we'd rather not do that.
983
984 if (buffer_ == buffer_end_ &&
985 ((buffer_size_after_limit_ != 0) ||
986 (total_bytes_read_ == current_limit_))) {
987 last_tag_ = 0; // Pretend we called ReadTag()...
988 legitimate_message_end_ = true; // ... and it hit EOF.
989 return true;
990 } else {
991 return false;
992 }
993}
994
995inline int CodedInputStream::CurrentPosition() const {
996 return total_bytes_read_ - (BufferSize() + buffer_size_after_limit_);
997}
998
999inline uint8* CodedOutputStream::GetDirectBufferForNBytesAndAdvance(int size) {
1000 if (buffer_size_ < size) {
1001 return NULL;
1002 } else {
1003 uint8* result = buffer_;
1004 Advance(size);
1005 return result;
1006 }
1007}
1008
1009inline uint8* CodedOutputStream::WriteVarint32ToArray(uint32 value,
1010 uint8* target) {
1011 if (value < 0x80) {
1012 *target = value;
1013 return target + 1;
1014 } else {
1015 return WriteVarint32FallbackToArray(value, target);
1016 }
1017}
1018
1019inline void CodedOutputStream::WriteVarint32SignExtended(int32 value) {
1020 if (value < 0) {
1021 WriteVarint64(static_cast<uint64>(value));
1022 } else {
1023 WriteVarint32(static_cast<uint32>(value));
1024 }
1025}
1026
1027inline uint8* CodedOutputStream::WriteVarint32SignExtendedToArray(
1028 int32 value, uint8* target) {
1029 if (value < 0) {
1030 return WriteVarint64ToArray(static_cast<uint64>(value), target);
1031 } else {
1032 return WriteVarint32ToArray(static_cast<uint32>(value), target);
1033 }
1034}
1035
1036inline uint8* CodedOutputStream::WriteLittleEndian32ToArray(uint32 value,
1037 uint8* target) {
1038#if defined(PROTOBUF_LITTLE_ENDIAN)
1039 memcpy(target, &value, sizeof(value));
1040#else
1041 target[0] = static_cast<uint8>(value);
1042 target[1] = static_cast<uint8>(value >> 8);
1043 target[2] = static_cast<uint8>(value >> 16);
1044 target[3] = static_cast<uint8>(value >> 24);
1045#endif
1046 return target + sizeof(value);
1047}
1048
1049inline uint8* CodedOutputStream::WriteLittleEndian64ToArray(uint64 value,
1050 uint8* target) {
1051#if defined(PROTOBUF_LITTLE_ENDIAN)
1052 memcpy(target, &value, sizeof(value));
1053#else
1054 uint32 part0 = static_cast<uint32>(value);
1055 uint32 part1 = static_cast<uint32>(value >> 32);
1056
1057 target[0] = static_cast<uint8>(part0);
1058 target[1] = static_cast<uint8>(part0 >> 8);
1059 target[2] = static_cast<uint8>(part0 >> 16);
1060 target[3] = static_cast<uint8>(part0 >> 24);
1061 target[4] = static_cast<uint8>(part1);
1062 target[5] = static_cast<uint8>(part1 >> 8);
1063 target[6] = static_cast<uint8>(part1 >> 16);
1064 target[7] = static_cast<uint8>(part1 >> 24);
1065#endif
1066 return target + sizeof(value);
1067}
1068
1069inline void CodedOutputStream::WriteTag(uint32 value) {
1070 WriteVarint32(value);
1071}
1072
1073inline uint8* CodedOutputStream::WriteTagToArray(
1074 uint32 value, uint8* target) {
1075 if (value < (1 << 7)) {
1076 target[0] = value;
1077 return target + 1;
1078 } else if (value < (1 << 14)) {
1079 target[0] = static_cast<uint8>(value | 0x80);
1080 target[1] = static_cast<uint8>(value >> 7);
1081 return target + 2;
1082 } else {
1083 return WriteVarint32FallbackToArray(value, target);
1084 }
1085}
1086
1087inline int CodedOutputStream::VarintSize32(uint32 value) {
1088 if (value < (1 << 7)) {
1089 return 1;
1090 } else {
1091 return VarintSize32Fallback(value);
1092 }
1093}
1094
1095inline int CodedOutputStream::VarintSize32SignExtended(int32 value) {
1096 if (value < 0) {
1097 return 10; // TODO(kenton): Make this a symbolic constant.
1098 } else {
1099 return VarintSize32(static_cast<uint32>(value));
1100 }
1101}
1102
1103inline void CodedOutputStream::WriteString(const string& str) {
1104 WriteRaw(str.data(), static_cast<int>(str.size()));
1105}
1106
1107inline void CodedOutputStream::WriteRawMaybeAliased(
1108 const void* data, int size) {
1109 if (aliasing_enabled_) {
1110 WriteAliasedRaw(data, size);
1111 } else {
1112 WriteRaw(data, size);
1113 }
1114}
1115
1116inline uint8* CodedOutputStream::WriteStringToArray(
1117 const string& str, uint8* target) {
1118 return WriteRawToArray(str.data(), static_cast<int>(str.size()), target);
1119}
1120
1121inline int CodedOutputStream::ByteCount() const {
1122 return total_bytes_ - buffer_size_;
1123}
1124
1125inline void CodedInputStream::Advance(int amount) {
1126 buffer_ += amount;
1127}
1128
1129inline void CodedOutputStream::Advance(int amount) {
1130 buffer_ += amount;
1131 buffer_size_ -= amount;
1132}
1133
1134inline void CodedInputStream::SetRecursionLimit(int limit) {
1135 recursion_limit_ = limit;
1136}
1137
1138inline bool CodedInputStream::IncrementRecursionDepth() {
1139 ++recursion_depth_;
1140 return recursion_depth_ <= recursion_limit_;
1141}
1142
1143inline void CodedInputStream::DecrementRecursionDepth() {
1144 if (recursion_depth_ > 0) --recursion_depth_;
1145}
1146
1147inline void CodedInputStream::SetExtensionRegistry(const DescriptorPool* pool,
1148 MessageFactory* factory) {
1149 extension_pool_ = pool;
1150 extension_factory_ = factory;
1151}
1152
1153inline const DescriptorPool* CodedInputStream::GetExtensionPool() {
1154 return extension_pool_;
1155}
1156
1157inline MessageFactory* CodedInputStream::GetExtensionFactory() {
1158 return extension_factory_;
1159}
1160
1161inline int CodedInputStream::BufferSize() const {
1162 return buffer_end_ - buffer_;
1163}
1164
1165inline CodedInputStream::CodedInputStream(ZeroCopyInputStream* input)
1166 : input_(input),
1167 buffer_(NULL),
1168 buffer_end_(NULL),
1169 total_bytes_read_(0),
1170 overflow_bytes_(0),
1171 last_tag_(0),
1172 legitimate_message_end_(false),
1173 aliasing_enabled_(false),
1174 current_limit_(kint32max),
1175 buffer_size_after_limit_(0),
1176 total_bytes_limit_(kDefaultTotalBytesLimit),
1177 total_bytes_warning_threshold_(kDefaultTotalBytesWarningThreshold),
1178 recursion_depth_(0),
1179 recursion_limit_(default_recursion_limit_),
1180 extension_pool_(NULL),
1181 extension_factory_(NULL) {
1182 // Eagerly Refresh() so buffer space is immediately available.
1183 Refresh();
1184}
1185
1186inline CodedInputStream::CodedInputStream(const uint8* buffer, int size)
1187 : input_(NULL),
1188 buffer_(buffer),
1189 buffer_end_(buffer + size),
1190 total_bytes_read_(size),
1191 overflow_bytes_(0),
1192 last_tag_(0),
1193 legitimate_message_end_(false),
1194 aliasing_enabled_(false),
1195 current_limit_(size),
1196 buffer_size_after_limit_(0),
1197 total_bytes_limit_(kDefaultTotalBytesLimit),
1198 total_bytes_warning_threshold_(kDefaultTotalBytesWarningThreshold),
1199 recursion_depth_(0),
1200 recursion_limit_(default_recursion_limit_),
1201 extension_pool_(NULL),
1202 extension_factory_(NULL) {
1203 // Note that setting current_limit_ == size is important to prevent some
1204 // code paths from trying to access input_ and segfaulting.
1205}
1206
1207inline bool CodedInputStream::IsFlat() const {
1208 return input_ == NULL;
1209}
1210
1211} // namespace io
1212} // namespace protobuf
1213
1214
1215#if defined(_MSC_VER) && _MSC_VER >= 1300
1216 #pragma runtime_checks("c", restore)
1217#endif // _MSC_VER
1218
1219} // namespace google
1220#endif // GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
1221