Google Git
Sign in
android / platform / prebuilts / libprotobuf / linux / refs/heads/android-games-sdk-game-text-input-release / . / src / google / protobuf / io / coded_stream.h
blob: c8fc994f916d047c0a7b176e53c9e946ebd752de [file] [log] [blame]
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
//
// This file contains the CodedInputStream and CodedOutputStream classes,
// which wrap a ZeroCopyInputStream or ZeroCopyOutputStream, respectively,
// and allow you to read or write individual pieces of data in various
// formats. In particular, these implement the varint encoding for
// integers, a simple variable-length encoding in which smaller numbers
// take fewer bytes.
//
// Typically these classes will only be used internally by the protocol
// buffer library in order to encode and decode protocol buffers. Clients
// of the library only need to know about this class if they wish to write
// custom message parsing or serialization procedures.
//
// CodedOutputStream example:
// // Write some data to "myfile". First we write a 4-byte "magic number"
// // to identify the file type, then write a length-delimited string. The
// // string is composed of a varint giving the length followed by the raw
// // bytes.
// int fd = open("myfile", O_CREAT | O_WRONLY);
// ZeroCopyOutputStream* raw_output = new FileOutputStream(fd);
// CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
//
// int magic_number = 1234;
// char text[] = "Hello world!";
// coded_output->WriteLittleEndian32(magic_number);
// coded_output->WriteVarint32(strlen(text));
// coded_output->WriteRaw(text, strlen(text));
//
// delete coded_output;
// delete raw_output;
// close(fd);
//
// CodedInputStream example:
// // Read a file created by the above code.
// int fd = open("myfile", O_RDONLY);
// ZeroCopyInputStream* raw_input = new FileInputStream(fd);
// CodedInputStream* coded_input = new CodedInputStream(raw_input);
//
// coded_input->ReadLittleEndian32(&magic_number);
// if (magic_number != 1234) {
// cerr << "File not in expected format." << endl;
// return;
// }
//
// uint32_t size;
// coded_input->ReadVarint32(&size);
//
// char* text = new char[size + 1];
// coded_input->ReadRaw(buffer, size);
// text[size] = '\0';
//
// delete coded_input;
// delete raw_input;
// close(fd);
//
// cout << "Text is: " << text << endl;
// delete [] text;
//
// For those who are interested, varint encoding is defined as follows:
//
// The encoding operates on unsigned integers of up to 64 bits in length.
// Each byte of the encoded value has the format:
// * bits 0-6: Seven bits of the number being encoded.
// * bit 7: Zero if this is the last byte in the encoding (in which
// case all remaining bits of the number are zero) or 1 if
// more bytes follow.
// The first byte contains the least-significant 7 bits of the number, the
// second byte (if present) contains the next-least-significant 7 bits,
// and so on. So, the binary number 1011000101011 would be encoded in two
// bytes as "10101011 00101100".
//
// In theory, varint could be used to encode integers of any length.
// However, for practicality we set a limit at 64 bits. The maximum encoded
// length of a number is thus 10 bytes.
#ifndef GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
#define GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
#include <assert.h>
#include <atomic>
#include <climits>
#include <cstddef>
#include <cstring>
#include <limits>
#include <string>
#include <type_traits>
#include <utility>
#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
// If MSVC has "/RTCc" set, it will complain about truncating casts at
// runtime. This file contains some intentional truncating casts.
#pragma runtime_checks("c", off)
#endif
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/strutil.h>
#include <google/protobuf/port.h>
#include <google/protobuf/stubs/port.h>
// Must be included last.
#include <google/protobuf/port_def.inc>
namespace google {
namespace protobuf {
class DescriptorPool;
class MessageFactory;
class ZeroCopyCodedInputStream;
namespace internal {
void MapTestForceDeterministic();
class EpsCopyByteStream;
} // namespace internal
namespace io {
// Defined in this file.
class CodedInputStream;
class CodedOutputStream;
// Defined in other files.
class ZeroCopyInputStream; // zero_copy_stream.h
class ZeroCopyOutputStream; // zero_copy_stream.h
// Class which reads and decodes binary data which is composed of varint-
// encoded integers and fixed-width pieces. Wraps a ZeroCopyInputStream.
// Most users will not need to deal with CodedInputStream.
//
// Most methods of CodedInputStream that return a bool return false if an
// underlying I/O error occurs or if the data is malformed. Once such a
// failure occurs, the CodedInputStream is broken and is no longer useful.
// After a failure, callers also should assume writes to "out" args may have
// occurred, though nothing useful can be determined from those writes.
class PROTOBUF_EXPORT CodedInputStream {
public:
// Create a CodedInputStream that reads from the given ZeroCopyInputStream.
explicit CodedInputStream(ZeroCopyInputStream* input);
// Create a CodedInputStream that reads from the given flat array. This is
// faster than using an ArrayInputStream. PushLimit(size) is implied by
// this constructor.
explicit CodedInputStream(const uint8_t* buffer, int size);
// Destroy the CodedInputStream and position the underlying
// ZeroCopyInputStream at the first unread byte. If an error occurred while
// reading (causing a method to return false), then the exact position of
// the input stream may be anywhere between the last value that was read
// successfully and the stream's byte limit.
~CodedInputStream();
// Return true if this CodedInputStream reads from a flat array instead of
// a ZeroCopyInputStream.
inline bool IsFlat() const;
// Skips a number of bytes. Returns false if an underlying read error
// occurs.
inline bool Skip(int count);
// Sets *data to point directly at the unread part of the CodedInputStream's
// underlying buffer, and *size to the size of that buffer, but does not
// advance the stream's current position. This will always either produce
// a non-empty buffer or return false. If the caller consumes any of
// this data, it should then call Skip() to skip over the consumed bytes.
// This may be useful for implementing external fast parsing routines for
// types of data not covered by the CodedInputStream interface.
bool GetDirectBufferPointer(const void** data, int* size);
// Like GetDirectBufferPointer, but this method is inlined, and does not
// attempt to Refresh() if the buffer is currently empty.
PROTOBUF_ALWAYS_INLINE
void GetDirectBufferPointerInline(const void** data, int* size);
// Read raw bytes, copying them into the given buffer.
bool ReadRaw(void* buffer, int size);
// Like ReadRaw, but reads into a string.
bool ReadString(std::string* buffer, int size);
// Read a 32-bit little-endian integer.
bool ReadLittleEndian32(uint32_t* value);
// Read a 64-bit little-endian integer.
bool ReadLittleEndian64(uint64_t* value);
// These methods read from an externally provided buffer. The caller is
// responsible for ensuring that the buffer has sufficient space.
// Read a 32-bit little-endian integer.
static const uint8_t* ReadLittleEndian32FromArray(const uint8_t* buffer,
uint32_t* value);
// Read a 64-bit little-endian integer.
static const uint8_t* ReadLittleEndian64FromArray(const uint8_t* buffer,
uint64_t* value);
// Read an unsigned integer with Varint encoding, truncating to 32 bits.
// Reading a 32-bit value is equivalent to reading a 64-bit one and casting
// it to uint32_t, but may be more efficient.
bool ReadVarint32(uint32_t* value);
// Read an unsigned integer with Varint encoding.
bool ReadVarint64(uint64_t* value);
// Reads a varint off the wire into an "int". This should be used for reading
// sizes off the wire (sizes of strings, submessages, bytes fields, etc).
//
// The value from the wire is interpreted as unsigned. If its value exceeds
// the representable value of an integer on this platform, instead of
// truncating we return false. Truncating (as performed by ReadVarint32()
// above) is an acceptable approach for fields representing an integer, but
// when we are parsing a size from the wire, truncating the value would result
// in us misparsing the payload.
bool ReadVarintSizeAsInt(int* value);
// Read a tag. This calls ReadVarint32() and returns the result, or returns
// zero (which is not a valid tag) if ReadVarint32() fails. Also, ReadTag
// (but not ReadTagNoLastTag) updates the last tag value, which can be checked
// with LastTagWas().
//
// Always inline because this is only called in one place per parse loop
// but it is called for every iteration of said loop, so it should be fast.
// GCC doesn't want to inline this by default.
PROTOBUF_ALWAYS_INLINE uint32_t ReadTag() {
return last_tag_ = ReadTagNoLastTag();
}
PROTOBUF_ALWAYS_INLINE uint32_t ReadTagNoLastTag();
// This usually a faster alternative to ReadTag() when cutoff is a manifest
// constant. It does particularly well for cutoff >= 127. The first part
// of the return value is the tag that was read, though it can also be 0 in
// the cases where ReadTag() would return 0. If the second part is true
// then the tag is known to be in [0, cutoff]. If not, the tag either is
// above cutoff or is 0. (There's intentional wiggle room when tag is 0,
// because that can arise in several ways, and for best performance we want
// to avoid an extra "is tag == 0?" check here.)
PROTOBUF_ALWAYS_INLINE
std::pair<uint32_t, bool> ReadTagWithCutoff(uint32_t cutoff) {
std::pair<uint32_t, bool> result = ReadTagWithCutoffNoLastTag(cutoff);
last_tag_ = result.first;
return result;
}
PROTOBUF_ALWAYS_INLINE
std::pair<uint32_t, bool> ReadTagWithCutoffNoLastTag(uint32_t cutoff);
// Usually returns true if calling ReadVarint32() now would produce the given
// value. Will always return false if ReadVarint32() would not return the
// given value. If ExpectTag() returns true, it also advances past
// the varint. For best performance, use a compile-time constant as the
// parameter.
// Always inline because this collapses to a small number of instructions
// when given a constant parameter, but GCC doesn't want to inline by default.
PROTOBUF_ALWAYS_INLINE bool ExpectTag(uint32_t expected);
// Like above, except this reads from the specified buffer. The caller is
// responsible for ensuring that the buffer is large enough to read a varint
// of the expected size. For best performance, use a compile-time constant as
// the expected tag parameter.
//
// Returns a pointer beyond the expected tag if it was found, or NULL if it
// was not.
PROTOBUF_ALWAYS_INLINE
static const uint8_t* ExpectTagFromArray(const uint8_t* buffer,
uint32_t expected);
// Usually returns true if no more bytes can be read. Always returns false
// if more bytes can be read. If ExpectAtEnd() returns true, a subsequent
// call to LastTagWas() will act as if ReadTag() had been called and returned
// zero, and ConsumedEntireMessage() will return true.
bool ExpectAtEnd();
// If the last call to ReadTag() or ReadTagWithCutoff() returned the given
// value, returns true. Otherwise, returns false.
// ReadTagNoLastTag/ReadTagWithCutoffNoLastTag do not preserve the last
// returned value.
//
// This is needed because parsers for some types of embedded messages
// (with field type TYPE_GROUP) don't actually know that they've reached the
// end of a message until they see an ENDGROUP tag, which was actually part
// of the enclosing message. The enclosing message would like to check that
// tag to make sure it had the right number, so it calls LastTagWas() on
// return from the embedded parser to check.
bool LastTagWas(uint32_t expected);
void SetLastTag(uint32_t tag) { last_tag_ = tag; }
// When parsing message (but NOT a group), this method must be called
// immediately after MergeFromCodedStream() returns (if it returns true)
// to further verify that the message ended in a legitimate way. For
// example, this verifies that parsing did not end on an end-group tag.
// It also checks for some cases where, due to optimizations,
// MergeFromCodedStream() can incorrectly return true.
bool ConsumedEntireMessage();
void SetConsumed() { legitimate_message_end_ = true; }
// Limits ----------------------------------------------------------
// Limits are used when parsing length-delimited embedded messages.
// After the message's length is read, PushLimit() is used to prevent
// the CodedInputStream from reading beyond that length. Once the
// embedded message has been parsed, PopLimit() is called to undo the
// limit.
// Opaque type used with PushLimit() and PopLimit(). Do not modify
// values of this type yourself. The only reason that this isn't a
// struct with private internals is for efficiency.
typedef int Limit;
// Places a limit on the number of bytes that the stream may read,
// starting from the current position. Once the stream hits this limit,
// it will act like the end of the input has been reached until PopLimit()
// is called.
//
// As the names imply, the stream conceptually has a stack of limits. The
// shortest limit on the stack is always enforced, even if it is not the
// top limit.
//
// The value returned by PushLimit() is opaque to the caller, and must
// be passed unchanged to the corresponding call to PopLimit().
Limit PushLimit(int byte_limit);
// Pops the last limit pushed by PushLimit(). The input must be the value
// returned by that call to PushLimit().
void PopLimit(Limit limit);
// Returns the number of bytes left until the nearest limit on the
// stack is hit, or -1 if no limits are in place.
int BytesUntilLimit() const;
// Returns current position relative to the beginning of the input stream.
int CurrentPosition() const;
// Total Bytes Limit -----------------------------------------------
// To prevent malicious users from sending excessively large messages
// and causing memory exhaustion, CodedInputStream imposes a hard limit on
// the total number of bytes it will read.
// Sets the maximum number of bytes that this CodedInputStream will read
// before refusing to continue. To prevent servers from allocating enormous
// amounts of memory to hold parsed messages, the maximum message length
// should be limited to the shortest length that will not harm usability.
// The default limit is INT_MAX (~2GB) and apps should set shorter limits
// if possible. An error will always be printed to stderr if the limit is
// reached.
//
// Note: setting a limit less than the current read position is interpreted
// as a limit on the current position.
//
// This is unrelated to PushLimit()/PopLimit().
void SetTotalBytesLimit(int total_bytes_limit);
// The Total Bytes Limit minus the Current Position, or -1 if the total bytes
// limit is INT_MAX.
int BytesUntilTotalBytesLimit() const;
// Recursion Limit -------------------------------------------------
// To prevent corrupt or malicious messages from causing stack overflows,
// we must keep track of the depth of recursion when parsing embedded
// messages and groups. CodedInputStream keeps track of this because it
// is the only object that is passed down the stack during parsing.
// Sets the maximum recursion depth. The default is 100.
void SetRecursionLimit(int limit);
int RecursionBudget() { return recursion_budget_; }
static int GetDefaultRecursionLimit() { return default_recursion_limit_; }
// Increments the current recursion depth. Returns true if the depth is
// under the limit, false if it has gone over.
bool IncrementRecursionDepth();
// Decrements the recursion depth if possible.
void DecrementRecursionDepth();
// Decrements the recursion depth blindly. This is faster than
// DecrementRecursionDepth(). It should be used only if all previous
// increments to recursion depth were successful.
void UnsafeDecrementRecursionDepth();
// Shorthand for make_pair(PushLimit(byte_limit), --recursion_budget_).
// Using this can reduce code size and complexity in some cases. The caller
// is expected to check that the second part of the result is non-negative (to
// bail out if the depth of recursion is too high) and, if all is well, to
// later pass the first part of the result to PopLimit() or similar.
std::pair<CodedInputStream::Limit, int> IncrementRecursionDepthAndPushLimit(
int byte_limit);
// Shorthand for PushLimit(ReadVarint32(&length) ? length : 0).
Limit ReadLengthAndPushLimit();
// Helper that is equivalent to: {
// bool result = ConsumedEntireMessage();
// PopLimit(limit);
// UnsafeDecrementRecursionDepth();
// return result; }
// Using this can reduce code size and complexity in some cases.
// Do not use unless the current recursion depth is greater than zero.
bool DecrementRecursionDepthAndPopLimit(Limit limit);
// Helper that is equivalent to: {
// bool result = ConsumedEntireMessage();
// PopLimit(limit);
// return result; }
// Using this can reduce code size and complexity in some cases.
bool CheckEntireMessageConsumedAndPopLimit(Limit limit);
// Extension Registry ----------------------------------------------
// ADVANCED USAGE: 99.9% of people can ignore this section.
//
// By default, when parsing extensions, the parser looks for extension
// definitions in the pool which owns the outer message's Descriptor.
// However, you may call SetExtensionRegistry() to provide an alternative
// pool instead. This makes it possible, for example, to parse a message
// using a generated class, but represent some extensions using
// DynamicMessage.
// Set the pool used to look up extensions. Most users do not need to call
// this as the correct pool will be chosen automatically.
//
// WARNING: It is very easy to misuse this. Carefully read the requirements
// below. Do not use this unless you are sure you need it. Almost no one
// does.
//
// Let's say you are parsing a message into message object m, and you want
// to take advantage of SetExtensionRegistry(). You must follow these
// requirements:
//
// The given DescriptorPool must contain m->GetDescriptor(). It is not
// sufficient for it to simply contain a descriptor that has the same name
// and content -- it must be the *exact object*. In other words:
// assert(pool->FindMessageTypeByName(m->GetDescriptor()->full_name()) ==
// m->GetDescriptor());
// There are two ways to satisfy this requirement:
// 1) Use m->GetDescriptor()->pool() as the pool. This is generally useless
// because this is the pool that would be used anyway if you didn't call
// SetExtensionRegistry() at all.
// 2) Use a DescriptorPool which has m->GetDescriptor()->pool() as an
// "underlay". Read the documentation for DescriptorPool for more
// information about underlays.
//
// You must also provide a MessageFactory. This factory will be used to
// construct Message objects representing extensions. The factory's
// GetPrototype() MUST return non-NULL for any Descriptor which can be found
// through the provided pool.
//
// If the provided factory might return instances of protocol-compiler-
// generated (i.e. compiled-in) types, or if the outer message object m is
// a generated type, then the given factory MUST have this property: If
// GetPrototype() is given a Descriptor which resides in
// DescriptorPool::generated_pool(), the factory MUST return the same
// prototype which MessageFactory::generated_factory() would return. That
// is, given a descriptor for a generated type, the factory must return an
// instance of the generated class (NOT DynamicMessage). However, when
// given a descriptor for a type that is NOT in generated_pool, the factory
// is free to return any implementation.
//
// The reason for this requirement is that generated sub-objects may be
// accessed via the standard (non-reflection) extension accessor methods,
// and these methods will down-cast the object to the generated class type.
// If the object is not actually of that type, the results would be undefined.
// On the other hand, if an extension is not compiled in, then there is no
// way the code could end up accessing it via the standard accessors -- the
// only way to access the extension is via reflection. When using reflection,
// DynamicMessage and generated messages are indistinguishable, so it's fine
// if these objects are represented using DynamicMessage.
//
// Using DynamicMessageFactory on which you have called
// SetDelegateToGeneratedFactory(true) should be sufficient to satisfy the
// above requirement.
//
// If either pool or factory is NULL, both must be NULL.
//
// Note that this feature is ignored when parsing "lite" messages as they do
// not have descriptors.
void SetExtensionRegistry(const DescriptorPool* pool,
MessageFactory* factory);
// Get the DescriptorPool set via SetExtensionRegistry(), or NULL if no pool
// has been provided.
const DescriptorPool* GetExtensionPool();
// Get the MessageFactory set via SetExtensionRegistry(), or NULL if no
// factory has been provided.
MessageFactory* GetExtensionFactory();
private:
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedInputStream);
const uint8_t* buffer_;
const uint8_t* buffer_end_; // pointer to the end of the buffer.
ZeroCopyInputStream* input_;
int total_bytes_read_; // total bytes read from input_, including
// the current buffer
// If total_bytes_read_ surpasses INT_MAX, we record the extra bytes here
// so that we can BackUp() on destruction.
int overflow_bytes_;
// LastTagWas() stuff.
uint32_t last_tag_; // result of last ReadTag() or ReadTagWithCutoff().
// This is set true by ReadTag{Fallback/Slow}() if it is called when exactly
// at EOF, or by ExpectAtEnd() when it returns true. This happens when we
// reach the end of a message and attempt to read another tag.
bool legitimate_message_end_;
// See EnableAliasing().
bool aliasing_enabled_;
// Limits
Limit current_limit_; // if position = -1, no limit is applied
// For simplicity, if the current buffer crosses a limit (either a normal
// limit created by PushLimit() or the total bytes limit), buffer_size_
// only tracks the number of bytes before that limit. This field
// contains the number of bytes after it. Note that this implies that if
// buffer_size_ == 0 and buffer_size_after_limit_ > 0, we know we've
// hit a limit. However, if both are zero, it doesn't necessarily mean
// we aren't at a limit -- the buffer may have ended exactly at the limit.
int buffer_size_after_limit_;
// Maximum number of bytes to read, period. This is unrelated to
// current_limit_. Set using SetTotalBytesLimit().
int total_bytes_limit_;
// Current recursion budget, controlled by IncrementRecursionDepth() and
// similar. Starts at recursion_limit_ and goes down: if this reaches
// -1 we are over budget.
int recursion_budget_;
// Recursion depth limit, set by SetRecursionLimit().
int recursion_limit_;
// See SetExtensionRegistry().
const DescriptorPool* extension_pool_;
MessageFactory* extension_factory_;
// Private member functions.
// Fallback when Skip() goes past the end of the current buffer.
bool SkipFallback(int count, int original_buffer_size);
// Advance the buffer by a given number of bytes.
void Advance(int amount);
// Back up input_ to the current buffer position.
void BackUpInputToCurrentPosition();
// Recomputes the value of buffer_size_after_limit_. Must be called after
// current_limit_ or total_bytes_limit_ changes.
void RecomputeBufferLimits();
// Writes an error message saying that we hit total_bytes_limit_.
void PrintTotalBytesLimitError();
// Called when the buffer runs out to request more data. Implies an
// Advance(BufferSize()).
bool Refresh();
// When parsing varints, we optimize for the common case of small values, and
// then optimize for the case when the varint fits within the current buffer
// piece. The Fallback method is used when we can't use the one-byte
// optimization. The Slow method is yet another fallback when the buffer is
// not large enough. Making the slow path out-of-line speeds up the common
// case by 10-15%. The slow path is fairly uncommon: it only triggers when a
// message crosses multiple buffers. Note: ReadVarint32Fallback() and
// ReadVarint64Fallback() are called frequently and generally not inlined, so
// they have been optimized to avoid "out" parameters. The former returns -1
// if it fails and the uint32_t it read otherwise. The latter has a bool
// indicating success or failure as part of its return type.
int64_t ReadVarint32Fallback(uint32_t first_byte_or_zero);
int ReadVarintSizeAsIntFallback();
std::pair<uint64_t, bool> ReadVarint64Fallback();
bool ReadVarint32Slow(uint32_t* value);
bool ReadVarint64Slow(uint64_t* value);
int ReadVarintSizeAsIntSlow();
bool ReadLittleEndian32Fallback(uint32_t* value);
bool ReadLittleEndian64Fallback(uint64_t* value);
// Fallback/slow methods for reading tags. These do not update last_tag_,
// but will set legitimate_message_end_ if we are at the end of the input
// stream.
uint32_t ReadTagFallback(uint32_t first_byte_or_zero);
uint32_t ReadTagSlow();
bool ReadStringFallback(std::string* buffer, int size);
// Return the size of the buffer.
int BufferSize() const;
static const int kDefaultTotalBytesLimit = INT_MAX;
static int default_recursion_limit_; // 100 by default.
friend class google::protobuf::ZeroCopyCodedInputStream;
friend class google::protobuf::internal::EpsCopyByteStream;
};
// EpsCopyOutputStream wraps a ZeroCopyOutputStream and exposes a new stream,
// which has the property you can write kSlopBytes (16 bytes) from the current
// position without bounds checks. The cursor into the stream is managed by
// the user of the class and is an explicit parameter in the methods. Careful
// use of this class, ie. keep ptr a local variable, eliminates the need to
// for the compiler to sync the ptr value between register and memory.
class PROTOBUF_EXPORT EpsCopyOutputStream {
public:
enum { kSlopBytes = 16 };
// Initialize from a stream.
EpsCopyOutputStream(ZeroCopyOutputStream* stream, bool deterministic,
uint8_t** pp)
: end_(buffer_),
stream_(stream),
is_serialization_deterministic_(deterministic) {
*pp = buffer_;
}
// Only for array serialization. No overflow protection, end_ will be the
// pointed to the end of the array. When using this the total size is already
// known, so no need to maintain the slop region.
EpsCopyOutputStream(void* data, int size, bool deterministic)
: end_(static_cast<uint8_t*>(data) + size),
buffer_end_(nullptr),
stream_(nullptr),
is_serialization_deterministic_(deterministic) {}
// Initialize from stream but with the first buffer already given (eager).
EpsCopyOutputStream(void* data, int size, ZeroCopyOutputStream* stream,
bool deterministic, uint8_t** pp)
: stream_(stream), is_serialization_deterministic_(deterministic) {
*pp = SetInitialBuffer(data, size);
}
// Flush everything that's written into the underlying ZeroCopyOutputStream
// and trims the underlying stream to the location of ptr.
uint8_t* Trim(uint8_t* ptr);
// After this it's guaranteed you can safely write kSlopBytes to ptr. This
// will never fail! The underlying stream can produce an error. Use HadError
// to check for errors.
PROTOBUF_NODISCARD uint8_t* EnsureSpace(uint8_t* ptr) {
if (PROTOBUF_PREDICT_FALSE(ptr >= end_)) {
return EnsureSpaceFallback(ptr);
}
return ptr;
}
uint8_t* WriteRaw(const void* data, int size, uint8_t* ptr) {
if (PROTOBUF_PREDICT_FALSE(end_ - ptr < size)) {
return WriteRawFallback(data, size, ptr);
}
std::memcpy(ptr, data, size);
return ptr + size;
}
// Writes the buffer specified by data, size to the stream. Possibly by
// aliasing the buffer (ie. not copying the data). The caller is responsible
// to make sure the buffer is alive for the duration of the
// ZeroCopyOutputStream.
#ifndef NDEBUG
PROTOBUF_NOINLINE
#endif
uint8_t* WriteRawMaybeAliased(const void* data, int size, uint8_t* ptr) {
if (aliasing_enabled_) {
return WriteAliasedRaw(data, size, ptr);
} else {
return WriteRaw(data, size, ptr);
}
}
#ifndef NDEBUG
PROTOBUF_NOINLINE
#endif
uint8_t* WriteStringMaybeAliased(uint32_t num, const std::string& s,
uint8_t* ptr) {
std::ptrdiff_t size = s.size();
if (PROTOBUF_PREDICT_FALSE(
size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
return WriteStringMaybeAliasedOutline(num, s, ptr);
}
ptr = UnsafeVarint((num << 3) | 2, ptr);
*ptr++ = static_cast<uint8_t>(size);
std::memcpy(ptr, s.data(), size);
return ptr + size;
}
uint8_t* WriteBytesMaybeAliased(uint32_t num, const std::string& s,
uint8_t* ptr) {
return WriteStringMaybeAliased(num, s, ptr);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteString(uint32_t num, const T& s,
uint8_t* ptr) {
std::ptrdiff_t size = s.size();
if (PROTOBUF_PREDICT_FALSE(
size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
return WriteStringOutline(num, s, ptr);
}
ptr = UnsafeVarint((num << 3) | 2, ptr);
*ptr++ = static_cast<uint8_t>(size);
std::memcpy(ptr, s.data(), size);
return ptr + size;
}
template <typename T>
#ifndef NDEBUG
PROTOBUF_NOINLINE
#endif
uint8_t* WriteBytes(uint32_t num, const T& s, uint8_t* ptr) {
return WriteString(num, s, ptr);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteInt32Packed(int num, const T& r,
int size, uint8_t* ptr) {
return WriteVarintPacked(num, r, size, ptr, Encode64);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteUInt32Packed(int num, const T& r,
int size, uint8_t* ptr) {
return WriteVarintPacked(num, r, size, ptr, Encode32);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteSInt32Packed(int num, const T& r,
int size, uint8_t* ptr) {
return WriteVarintPacked(num, r, size, ptr, ZigZagEncode32);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteInt64Packed(int num, const T& r,
int size, uint8_t* ptr) {
return WriteVarintPacked(num, r, size, ptr, Encode64);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteUInt64Packed(int num, const T& r,
int size, uint8_t* ptr) {
return WriteVarintPacked(num, r, size, ptr, Encode64);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteSInt64Packed(int num, const T& r,
int size, uint8_t* ptr) {
return WriteVarintPacked(num, r, size, ptr, ZigZagEncode64);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteEnumPacked(int num, const T& r, int size,
uint8_t* ptr) {
return WriteVarintPacked(num, r, size, ptr, Encode64);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteFixedPacked(int num, const T& r,
uint8_t* ptr) {
ptr = EnsureSpace(ptr);
constexpr auto element_size = sizeof(typename T::value_type);
auto size = r.size() * element_size;
ptr = WriteLengthDelim(num, size, ptr);
return WriteRawLittleEndian<element_size>(r.data(), static_cast<int>(size),
ptr);
}
// Returns true if there was an underlying I/O error since this object was
// created.
bool HadError() const { return had_error_; }
// Instructs the EpsCopyOutputStream to allow the underlying
// ZeroCopyOutputStream to hold pointers to the original structure instead of
// copying, if it supports it (i.e. output->AllowsAliasing() is true). If the
// underlying stream does not support aliasing, then enabling it has no
// affect. For now, this only affects the behavior of
// WriteRawMaybeAliased().
//
// NOTE: It is caller's responsibility to ensure that the chunk of memory
// remains live until all of the data has been consumed from the stream.
void EnableAliasing(bool enabled);
// See documentation on CodedOutputStream::SetSerializationDeterministic.
void SetSerializationDeterministic(bool value) {
is_serialization_deterministic_ = value;
}
// See documentation on CodedOutputStream::IsSerializationDeterministic.
bool IsSerializationDeterministic() const {
return is_serialization_deterministic_;
}
// The number of bytes written to the stream at position ptr, relative to the
// stream's overall position.
int64_t ByteCount(uint8_t* ptr) const;
private:
uint8_t* end_;
uint8_t* buffer_end_ = buffer_;
uint8_t buffer_[2 * kSlopBytes];
ZeroCopyOutputStream* stream_;
bool had_error_ = false;
bool aliasing_enabled_ = false; // See EnableAliasing().
bool is_serialization_deterministic_;
bool skip_check_consistency = false;
uint8_t* EnsureSpaceFallback(uint8_t* ptr);
inline uint8_t* Next();
int Flush(uint8_t* ptr);
std::ptrdiff_t GetSize(uint8_t* ptr) const {
GOOGLE_DCHECK(ptr <= end_ + kSlopBytes); // NOLINT
return end_ + kSlopBytes - ptr;
}
uint8_t* Error() {
had_error_ = true;
// We use the patch buffer to always guarantee space to write to.
end_ = buffer_ + kSlopBytes;
return buffer_;
}
static constexpr int TagSize(uint32_t tag) {
return (tag < (1 << 7)) ? 1
: (tag < (1 << 14)) ? 2
: (tag < (1 << 21)) ? 3
: (tag < (1 << 28)) ? 4
: 5;
}
PROTOBUF_ALWAYS_INLINE uint8_t* WriteTag(uint32_t num, uint32_t wt,
uint8_t* ptr) {
GOOGLE_DCHECK(ptr < end_); // NOLINT
return UnsafeVarint((num << 3) | wt, ptr);
}
PROTOBUF_ALWAYS_INLINE uint8_t* WriteLengthDelim(int num, uint32_t size,
uint8_t* ptr) {
ptr = WriteTag(num, 2, ptr);
return UnsafeWriteSize(size, ptr);
}
uint8_t* WriteRawFallback(const void* data, int size, uint8_t* ptr);
uint8_t* WriteAliasedRaw(const void* data, int size, uint8_t* ptr);
uint8_t* WriteStringMaybeAliasedOutline(uint32_t num, const std::string& s,
uint8_t* ptr);
uint8_t* WriteStringOutline(uint32_t num, const std::string& s, uint8_t* ptr);
template <typename T, typename E>
PROTOBUF_ALWAYS_INLINE uint8_t* WriteVarintPacked(int num, const T& r,
int size, uint8_t* ptr,
const E& encode) {
ptr = EnsureSpace(ptr);
ptr = WriteLengthDelim(num, size, ptr);
auto it = r.data();
auto end = it + r.size();
do {
ptr = EnsureSpace(ptr);
ptr = UnsafeVarint(encode(*it++), ptr);
} while (it < end);
return ptr;
}
static uint32_t Encode32(uint32_t v) { return v; }
static uint64_t Encode64(uint64_t v) { return v; }
static uint32_t ZigZagEncode32(int32_t v) {
return (static_cast<uint32_t>(v) << 1) ^ static_cast<uint32_t>(v >> 31);
}
static uint64_t ZigZagEncode64(int64_t v) {
return (static_cast<uint64_t>(v) << 1) ^ static_cast<uint64_t>(v >> 63);
}
template <typename T>
PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeVarint(T value, uint8_t* ptr) {
static_assert(std::is_unsigned<T>::value,
"Varint serialization must be unsigned");
ptr[0] = static_cast<uint8_t>(value);
if (value < 0x80) {
return ptr + 1;
}
// Turn on continuation bit in the byte we just wrote.
ptr[0] |= static_cast<uint8_t>(0x80);
value >>= 7;
ptr[1] = static_cast<uint8_t>(value);
if (value < 0x80) {
return ptr + 2;
}
ptr += 2;
do {
// Turn on continuation bit in the byte we just wrote.
ptr[-1] |= static_cast<uint8_t>(0x80);
value >>= 7;
*ptr = static_cast<uint8_t>(value);
++ptr;
} while (value >= 0x80);
return ptr;
}
PROTOBUF_ALWAYS_INLINE static uint8_t* UnsafeWriteSize(uint32_t value,
uint8_t* ptr) {
while (PROTOBUF_PREDICT_FALSE(value >= 0x80)) {
*ptr = static_cast<uint8_t>(value | 0x80);
value >>= 7;
++ptr;
}
*ptr++ = static_cast<uint8_t>(value);
return ptr;
}
template <int S>
uint8_t* WriteRawLittleEndian(const void* data, int size, uint8_t* ptr);
#if !defined(PROTOBUF_LITTLE_ENDIAN) || \
defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
uint8_t* WriteRawLittleEndian32(const void* data, int size, uint8_t* ptr);
uint8_t* WriteRawLittleEndian64(const void* data, int size, uint8_t* ptr);
#endif
// These methods are for CodedOutputStream. Ideally they should be private
// but to match current behavior of CodedOutputStream as close as possible
// we allow it some functionality.
public:
uint8_t* SetInitialBuffer(void* data, int size) {
auto ptr = static_cast<uint8_t*>(data);
if (size > kSlopBytes) {
end_ = ptr + size - kSlopBytes;
buffer_end_ = nullptr;
return ptr;
} else {
end_ = buffer_ + size;
buffer_end_ = ptr;
return buffer_;
}
}
private:
// Needed by CodedOutputStream HadError. HadError needs to flush the patch
// buffers to ensure there is no error as of yet.
uint8_t* FlushAndResetBuffer(uint8_t*);
// The following functions mimic the old CodedOutputStream behavior as close
// as possible. They flush the current state to the stream, behave as
// the old CodedOutputStream and then return to normal operation.
bool Skip(int count, uint8_t** pp);
bool GetDirectBufferPointer(void** data, int* size, uint8_t** pp);
uint8_t* GetDirectBufferForNBytesAndAdvance(int size, uint8_t** pp);
friend class CodedOutputStream;
};
template <>
inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<1>(const void* data,
int size,
uint8_t* ptr) {
return WriteRaw(data, size, ptr);
}
template <>
inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<4>(const void* data,
int size,
uint8_t* ptr) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
return WriteRaw(data, size, ptr);
#else
return WriteRawLittleEndian32(data, size, ptr);
#endif
}
template <>
inline uint8_t* EpsCopyOutputStream::WriteRawLittleEndian<8>(const void* data,
int size,
uint8_t* ptr) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
return WriteRaw(data, size, ptr);
#else
return WriteRawLittleEndian64(data, size, ptr);
#endif
}
// Class which encodes and writes binary data which is composed of varint-
// encoded integers and fixed-width pieces. Wraps a ZeroCopyOutputStream.
// Most users will not need to deal with CodedOutputStream.
//
// Most methods of CodedOutputStream which return a bool return false if an
// underlying I/O error occurs. Once such a failure occurs, the
// CodedOutputStream is broken and is no longer useful. The Write* methods do
// not return the stream status, but will invalidate the stream if an error
// occurs. The client can probe HadError() to determine the status.
//
// Note that every method of CodedOutputStream which writes some data has
// a corresponding static "ToArray" version. These versions write directly
// to the provided buffer, returning a pointer past the last written byte.
// They require that the buffer has sufficient capacity for the encoded data.
// This allows an optimization where we check if an output stream has enough
// space for an entire message before we start writing and, if there is, we
// call only the ToArray methods to avoid doing bound checks for each
// individual value.
// i.e., in the example above:
//
// CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
// int magic_number = 1234;
// char text[] = "Hello world!";
//
// int coded_size = sizeof(magic_number) +
// CodedOutputStream::VarintSize32(strlen(text)) +
// strlen(text);
//
// uint8_t* buffer =
// coded_output->GetDirectBufferForNBytesAndAdvance(coded_size);
// if (buffer != nullptr) {
// // The output stream has enough space in the buffer: write directly to
// // the array.
// buffer = CodedOutputStream::WriteLittleEndian32ToArray(magic_number,
// buffer);
// buffer = CodedOutputStream::WriteVarint32ToArray(strlen(text), buffer);
// buffer = CodedOutputStream::WriteRawToArray(text, strlen(text), buffer);
// } else {
// // Make bound-checked writes, which will ask the underlying stream for
// // more space as needed.
// coded_output->WriteLittleEndian32(magic_number);
// coded_output->WriteVarint32(strlen(text));
// coded_output->WriteRaw(text, strlen(text));
// }
//
// delete coded_output;
class PROTOBUF_EXPORT CodedOutputStream {
public:
// Creates a CodedOutputStream that writes to the given `stream`.
// The provided stream must publicly derive from `ZeroCopyOutputStream`.
template <class Stream, class = typename std::enable_if<std::is_base_of<
ZeroCopyOutputStream, Stream>::value>::type>
explicit CodedOutputStream(Stream* stream);
// Creates a CodedOutputStream that writes to the given `stream`, and does
// an 'eager initialization' of the internal state if `eager_init` is true.
// The provided stream must publicly derive from `ZeroCopyOutputStream`.
template <class Stream, class = typename std::enable_if<std::is_base_of<
ZeroCopyOutputStream, Stream>::value>::type>
CodedOutputStream(Stream* stream, bool eager_init);
// Destroy the CodedOutputStream and position the underlying
// ZeroCopyOutputStream immediately after the last byte written.
~CodedOutputStream();
// Returns true if there was an underlying I/O error since this object was
// created. On should call Trim before this function in order to catch all
// errors.
bool HadError() {
cur_ = impl_.FlushAndResetBuffer(cur_);
GOOGLE_DCHECK(cur_);
return impl_.HadError();
}
// Trims any unused space in the underlying buffer so that its size matches
// the number of bytes written by this stream. The underlying buffer will
// automatically be trimmed when this stream is destroyed; this call is only
// necessary if the underlying buffer is accessed *before* the stream is
// destroyed.
void Trim() { cur_ = impl_.Trim(cur_); }
// Skips a number of bytes, leaving the bytes unmodified in the underlying
// buffer. Returns false if an underlying write error occurs. This is
// mainly useful with GetDirectBufferPointer().
// Note of caution, the skipped bytes may contain uninitialized data. The
// caller must make sure that the skipped bytes are properly initialized,
// otherwise you might leak bytes from your heap.
bool Skip(int count) { return impl_.Skip(count, &cur_); }
// Sets *data to point directly at the unwritten part of the
// CodedOutputStream's underlying buffer, and *size to the size of that
// buffer, but does not advance the stream's current position. This will
// always either produce a non-empty buffer or return false. If the caller
// writes any data to this buffer, it should then call Skip() to skip over
// the consumed bytes. This may be useful for implementing external fast
// serialization routines for types of data not covered by the
// CodedOutputStream interface.
bool GetDirectBufferPointer(void** data, int* size) {
return impl_.GetDirectBufferPointer(data, size, &cur_);
}
// If there are at least "size" bytes available in the current buffer,
// returns a pointer directly into the buffer and advances over these bytes.
// The caller may then write directly into this buffer (e.g. using the
// *ToArray static methods) rather than go through CodedOutputStream. If
// there are not enough bytes available, returns NULL. The return pointer is
// invalidated as soon as any other non-const method of CodedOutputStream
// is called.
inline uint8_t* GetDirectBufferForNBytesAndAdvance(int size) {
return impl_.GetDirectBufferForNBytesAndAdvance(size, &cur_);
}
// Write raw bytes, copying them from the given buffer.
void WriteRaw(const void* buffer, int size) {
cur_ = impl_.WriteRaw(buffer, size, cur_);
}
// Like WriteRaw() but will try to write aliased data if aliasing is
// turned on.
void WriteRawMaybeAliased(const void* data, int size);
// Like WriteRaw() but writing directly to the target array.
// This is _not_ inlined, as the compiler often optimizes memcpy into inline
// copy loops. Since this gets called by every field with string or bytes
// type, inlining may lead to a significant amount of code bloat, with only a
// minor performance gain.
static uint8_t* WriteRawToArray(const void* buffer, int size,
uint8_t* target);
// Equivalent to WriteRaw(str.data(), str.size()).
void WriteString(const std::string& str);
// Like WriteString() but writing directly to the target array.
static uint8_t* WriteStringToArray(const std::string& str, uint8_t* target);
// Write the varint-encoded size of str followed by str.
static uint8_t* WriteStringWithSizeToArray(const std::string& str,
uint8_t* target);
// Write a 32-bit little-endian integer.
void WriteLittleEndian32(uint32_t value) {
cur_ = impl_.EnsureSpace(cur_);
SetCur(WriteLittleEndian32ToArray(value, Cur()));
}
// Like WriteLittleEndian32() but writing directly to the target array.
static uint8_t* WriteLittleEndian32ToArray(uint32_t value, uint8_t* target);
// Write a 64-bit little-endian integer.
void WriteLittleEndian64(uint64_t value) {
cur_ = impl_.EnsureSpace(cur_);
SetCur(WriteLittleEndian64ToArray(value, Cur()));
}
// Like WriteLittleEndian64() but writing directly to the target array.
static uint8_t* WriteLittleEndian64ToArray(uint64_t value, uint8_t* target);
// Write an unsigned integer with Varint encoding. Writing a 32-bit value
// is equivalent to casting it to uint64_t and writing it as a 64-bit value,
// but may be more efficient.
void WriteVarint32(uint32_t value);
// Like WriteVarint32() but writing directly to the target array.
static uint8_t* WriteVarint32ToArray(uint32_t value, uint8_t* target);
// Like WriteVarint32() but writing directly to the target array, and with
// the less common-case paths being out of line rather than inlined.
static uint8_t* WriteVarint32ToArrayOutOfLine(uint32_t value,
uint8_t* target);
// Write an unsigned integer with Varint encoding.
void WriteVarint64(uint64_t value);
// Like WriteVarint64() but writing directly to the target array.
static uint8_t* WriteVarint64ToArray(uint64_t value, uint8_t* target);
// Equivalent to WriteVarint32() except when the value is negative,
// in which case it must be sign-extended to a full 10 bytes.
void WriteVarint32SignExtended(int32_t value);
// Like WriteVarint32SignExtended() but writing directly to the target array.
static uint8_t* WriteVarint32SignExtendedToArray(int32_t value,
uint8_t* target);
// This is identical to WriteVarint32(), but optimized for writing tags.
// In particular, if the input is a compile-time constant, this method
// compiles down to a couple instructions.
// Always inline because otherwise the aforementioned optimization can't work,
// but GCC by default doesn't want to inline this.
void WriteTag(uint32_t value);
// Like WriteTag() but writing directly to the target array.
PROTOBUF_ALWAYS_INLINE
static uint8_t* WriteTagToArray(uint32_t value, uint8_t* target);
// Returns the number of bytes needed to encode the given value as a varint.
static size_t VarintSize32(uint32_t value);
// Returns the number of bytes needed to encode the given value as a varint.
static size_t VarintSize64(uint64_t value);
// If negative, 10 bytes. Otherwise, same as VarintSize32().
static size_t VarintSize32SignExtended(int32_t value);
// Same as above, plus one. The additional one comes at no compute cost.
static size_t VarintSize32PlusOne(uint32_t value);
static size_t VarintSize64PlusOne(uint64_t value);
static size_t VarintSize32SignExtendedPlusOne(int32_t value);
// Compile-time equivalent of VarintSize32().
template <uint32_t Value>
struct StaticVarintSize32 {
static const size_t value = (Value < (1 << 7)) ? 1
: (Value < (1 << 14)) ? 2
: (Value < (1 << 21)) ? 3
: (Value < (1 << 28)) ? 4
: 5;
};
// Returns the total number of bytes written since this object was created.
int ByteCount() const {
return static_cast<int>(impl_.ByteCount(cur_) - start_count_);
}
// Instructs the CodedOutputStream to allow the underlying
// ZeroCopyOutputStream to hold pointers to the original structure instead of
// copying, if it supports it (i.e. output->AllowsAliasing() is true). If the
// underlying stream does not support aliasing, then enabling it has no
// affect. For now, this only affects the behavior of
// WriteRawMaybeAliased().
//
// NOTE: It is caller's responsibility to ensure that the chunk of memory
// remains live until all of the data has been consumed from the stream.
void EnableAliasing(bool enabled) { impl_.EnableAliasing(enabled); }
// Indicate to the serializer whether the user wants deterministic
// serialization. The default when this is not called comes from the global
// default, controlled by SetDefaultSerializationDeterministic.
//
// What deterministic serialization means is entirely up to the driver of the
// serialization process (i.e. the caller of methods like WriteVarint32). In
// the case of serializing a proto buffer message using one of the methods of
// MessageLite, this means that for a given binary equal messages will always
// be serialized to the same bytes. This implies:
//
// * Repeated serialization of a message will return the same bytes.
//
// * Different processes running the same binary (including on different
// machines) will serialize equal messages to the same bytes.
//
// Note that this is *not* canonical across languages. It is also unstable
// across different builds with intervening message definition changes, due to
// unknown fields. Users who need canonical serialization (e.g. persistent
// storage in a canonical form, fingerprinting) should define their own
// canonicalization specification and implement the serializer using
// reflection APIs rather than relying on this API.
void SetSerializationDeterministic(bool value) {
impl_.SetSerializationDeterministic(value);
}
// Return whether the user wants deterministic serialization. See above.
bool IsSerializationDeterministic() const {
return impl_.IsSerializationDeterministic();
}
static bool IsDefaultSerializationDeterministic() {
return default_serialization_deterministic_.load(
std::memory_order_relaxed) != 0;
}
template <typename Func>
void Serialize(const Func& func);
uint8_t* Cur() const { return cur_; }
void SetCur(uint8_t* ptr) { cur_ = ptr; }
EpsCopyOutputStream* EpsCopy() { return &impl_; }
private:
template <class Stream>
void InitEagerly(Stream* stream);
EpsCopyOutputStream impl_;
uint8_t* cur_;
int64_t start_count_;
static std::atomic<bool> default_serialization_deterministic_;
// See above. Other projects may use "friend" to allow them to call this.
// After SetDefaultSerializationDeterministic() completes, all protocol
// buffer serializations will be deterministic by default. Thread safe.
// However, the meaning of "after" is subtle here: to be safe, each thread
// that wants deterministic serialization by default needs to call
// SetDefaultSerializationDeterministic() or ensure on its own that another
// thread has done so.
friend void internal::MapTestForceDeterministic();
static void SetDefaultSerializationDeterministic() {
default_serialization_deterministic_.store(true, std::memory_order_relaxed);
}
// REQUIRES: value >= 0x80, and that (value & 7f) has been written to *target.
static uint8_t* WriteVarint32ToArrayOutOfLineHelper(uint32_t value,
uint8_t* target);
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedOutputStream);
};
// inline methods ====================================================
// The vast majority of varints are only one byte. These inline
// methods optimize for that case.
inline bool CodedInputStream::ReadVarint32(uint32_t* value) {
uint32_t v = 0;
if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
v = *buffer_;
if (v < 0x80) {
*value = v;
Advance(1);
return true;
}
}
int64_t result = ReadVarint32Fallback(v);
*value = static_cast<uint32_t>(result);
return result >= 0;
}
inline bool CodedInputStream::ReadVarint64(uint64_t* value) {
if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
*value = *buffer_;
Advance(1);
return true;
}
std::pair<uint64_t, bool> p = ReadVarint64Fallback();
*value = p.first;
return p.second;
}
inline bool CodedInputStream::ReadVarintSizeAsInt(int* value) {
if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
int v = *buffer_;
if (v < 0x80) {
*value = v;
Advance(1);
return true;
}
}
*value = ReadVarintSizeAsIntFallback();
return *value >= 0;
}
// static
inline const uint8_t* CodedInputStream::ReadLittleEndian32FromArray(
const uint8_t* buffer, uint32_t* value) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
memcpy(value, buffer, sizeof(*value));
return buffer + sizeof(*value);
#else
*value = (static_cast<uint32_t>(buffer[0])) |
(static_cast<uint32_t>(buffer[1]) << 8) |
(static_cast<uint32_t>(buffer[2]) << 16) |
(static_cast<uint32_t>(buffer[3]) << 24);
return buffer + sizeof(*value);
#endif
}
// static
inline const uint8_t* CodedInputStream::ReadLittleEndian64FromArray(
const uint8_t* buffer, uint64_t* value) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
memcpy(value, buffer, sizeof(*value));
return buffer + sizeof(*value);
#else
uint32_t part0 = (static_cast<uint32_t>(buffer[0])) |
(static_cast<uint32_t>(buffer[1]) << 8) |
(static_cast<uint32_t>(buffer[2]) << 16) |
(static_cast<uint32_t>(buffer[3]) << 24);
uint32_t part1 = (static_cast<uint32_t>(buffer[4])) |
(static_cast<uint32_t>(buffer[5]) << 8) |
(static_cast<uint32_t>(buffer[6]) << 16) |
(static_cast<uint32_t>(buffer[7]) << 24);
*value = static_cast<uint64_t>(part0) | (static_cast<uint64_t>(part1) << 32);
return buffer + sizeof(*value);
#endif
}
inline bool CodedInputStream::ReadLittleEndian32(uint32_t* value) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
buffer_ = ReadLittleEndian32FromArray(buffer_, value);
return true;
} else {
return ReadLittleEndian32Fallback(value);
}
#else
return ReadLittleEndian32Fallback(value);
#endif
}
inline bool CodedInputStream::ReadLittleEndian64(uint64_t* value) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
if (PROTOBUF_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
buffer_ = ReadLittleEndian64FromArray(buffer_, value);
return true;
} else {
return ReadLittleEndian64Fallback(value);
}
#else
return ReadLittleEndian64Fallback(value);
#endif
}
inline uint32_t CodedInputStream::ReadTagNoLastTag() {
uint32_t v = 0;
if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
v = *buffer_;
if (v < 0x80) {
Advance(1);
return v;
}
}
v = ReadTagFallback(v);
return v;
}
inline std::pair<uint32_t, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
uint32_t cutoff) {
// In performance-sensitive code we can expect cutoff to be a compile-time
// constant, and things like "cutoff >= kMax1ByteVarint" to be evaluated at
// compile time.
uint32_t first_byte_or_zero = 0;
if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_)) {
// Hot case: buffer_ non_empty, buffer_[0] in [1, 128).
// TODO(gpike): Is it worth rearranging this? E.g., if the number of fields
// is large enough then is it better to check for the two-byte case first?
first_byte_or_zero = buffer_[0];
if (static_cast<int8_t>(buffer_[0]) > 0) {
const uint32_t kMax1ByteVarint = 0x7f;
uint32_t tag = buffer_[0];
Advance(1);
return std::make_pair(tag, cutoff >= kMax1ByteVarint || tag <= cutoff);
}
// Other hot case: cutoff >= 0x80, buffer_ has at least two bytes available,
// and tag is two bytes. The latter is tested by bitwise-and-not of the
// first byte and the second byte.
if (cutoff >= 0x80 && PROTOBUF_PREDICT_TRUE(buffer_ + 1 < buffer_end_) &&
PROTOBUF_PREDICT_TRUE((buffer_[0] & ~buffer_[1]) >= 0x80)) {
const uint32_t kMax2ByteVarint = (0x7f << 7) + 0x7f;
uint32_t tag = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
Advance(2);
// It might make sense to test for tag == 0 now, but it is so rare that
// that we don't bother. A varint-encoded 0 should be one byte unless
// the encoder lost its mind. The second part of the return value of
// this function is allowed to be either true or false if the tag is 0,
// so we don't have to check for tag == 0. We may need to check whether
// it exceeds cutoff.
bool at_or_below_cutoff = cutoff >= kMax2ByteVarint || tag <= cutoff;
return std::make_pair(tag, at_or_below_cutoff);
}
}
// Slow path
const uint32_t tag = ReadTagFallback(first_byte_or_zero);
return std::make_pair(tag, static_cast<uint32_t>(tag - 1) < cutoff);
}
inline bool CodedInputStream::LastTagWas(uint32_t expected) {
return last_tag_ == expected;
}
inline bool CodedInputStream::ConsumedEntireMessage() {
return legitimate_message_end_;
}
inline bool CodedInputStream::ExpectTag(uint32_t expected) {
if (expected < (1 << 7)) {
if (PROTOBUF_PREDICT_TRUE(buffer_ < buffer_end_) &&
buffer_[0] == expected) {
Advance(1);
return true;
} else {
return false;
}
} else if (expected < (1 << 14)) {
if (PROTOBUF_PREDICT_TRUE(BufferSize() >= 2) &&
buffer_[0] == static_cast<uint8_t>(expected | 0x80) &&
buffer_[1] == static_cast<uint8_t>(expected >> 7)) {
Advance(2);
return true;
} else {
return false;
}
} else {
// Don't bother optimizing for larger values.
return false;
}
}
inline const uint8_t* CodedInputStream::ExpectTagFromArray(
const uint8_t* buffer, uint32_t expected) {
if (expected < (1 << 7)) {
if (buffer[0] == expected) {
return buffer + 1;
}
} else if (expected < (1 << 14)) {
if (buffer[0] == static_cast<uint8_t>(expected | 0x80) &&
buffer[1] == static_cast<uint8_t>(expected >> 7)) {
return buffer + 2;
}
}
return nullptr;
}
inline void CodedInputStream::GetDirectBufferPointerInline(const void** data,
int* size) {
*data = buffer_;
*size = static_cast<int>(buffer_end_ - buffer_);
}
inline bool CodedInputStream::ExpectAtEnd() {
// If we are at a limit we know no more bytes can be read. Otherwise, it's
// hard to say without calling Refresh(), and we'd rather not do that.
if (buffer_ == buffer_end_ && ((buffer_size_after_limit_ != 0) ||
(total_bytes_read_ == current_limit_))) {
last_tag_ = 0; // Pretend we called ReadTag()...
legitimate_message_end_ = true; // ... and it hit EOF.
return true;
} else {
return false;
}
}
inline int CodedInputStream::CurrentPosition() const {
return total_bytes_read_ - (BufferSize() + buffer_size_after_limit_);
}
inline void CodedInputStream::Advance(int amount) { buffer_ += amount; }
inline void CodedInputStream::SetRecursionLimit(int limit) {
recursion_budget_ += limit - recursion_limit_;
recursion_limit_ = limit;
}
inline bool CodedInputStream::IncrementRecursionDepth() {
--recursion_budget_;
return recursion_budget_ >= 0;
}
inline void CodedInputStream::DecrementRecursionDepth() {
if (recursion_budget_ < recursion_limit_) ++recursion_budget_;
}
inline void CodedInputStream::UnsafeDecrementRecursionDepth() {
assert(recursion_budget_ < recursion_limit_);
++recursion_budget_;
}
inline void CodedInputStream::SetExtensionRegistry(const DescriptorPool* pool,
MessageFactory* factory) {
extension_pool_ = pool;
extension_factory_ = factory;
}
inline const DescriptorPool* CodedInputStream::GetExtensionPool() {
return extension_pool_;
}
inline MessageFactory* CodedInputStream::GetExtensionFactory() {
return extension_factory_;
}
inline int CodedInputStream::BufferSize() const {
return static_cast<int>(buffer_end_ - buffer_);
}
inline CodedInputStream::CodedInputStream(ZeroCopyInputStream* input)
: buffer_(nullptr),
buffer_end_(nullptr),
input_(input),
total_bytes_read_(0),
overflow_bytes_(0),
last_tag_(0),
legitimate_message_end_(false),
aliasing_enabled_(false),
current_limit_(std::numeric_limits<int32_t>::max()),
buffer_size_after_limit_(0),
total_bytes_limit_(kDefaultTotalBytesLimit),
recursion_budget_(default_recursion_limit_),
recursion_limit_(default_recursion_limit_),
extension_pool_(nullptr),
extension_factory_(nullptr) {
// Eagerly Refresh() so buffer space is immediately available.
Refresh();
}
inline CodedInputStream::CodedInputStream(const uint8_t* buffer, int size)
: buffer_(buffer),
buffer_end_(buffer + size),
input_(nullptr),
total_bytes_read_(size),
overflow_bytes_(0),
last_tag_(0),
legitimate_message_end_(false),
aliasing_enabled_(false),
current_limit_(size),
buffer_size_after_limit_(0),
total_bytes_limit_(kDefaultTotalBytesLimit),
recursion_budget_(default_recursion_limit_),
recursion_limit_(default_recursion_limit_),
extension_pool_(nullptr),
extension_factory_(nullptr) {
// Note that setting current_limit_ == size is important to prevent some
// code paths from trying to access input_ and segfaulting.
}
inline bool CodedInputStream::IsFlat() const { return input_ == nullptr; }
inline bool CodedInputStream::Skip(int count) {
if (count < 0) return false; // security: count is often user-supplied
const int original_buffer_size = BufferSize();
if (count <= original_buffer_size) {
// Just skipping within the current buffer. Easy.
Advance(count);
return true;
}
return SkipFallback(count, original_buffer_size);
}
template <class Stream, class>
inline CodedOutputStream::CodedOutputStream(Stream* stream)
: impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
start_count_(stream->ByteCount()) {
InitEagerly(stream);
}
template <class Stream, class>
inline CodedOutputStream::CodedOutputStream(Stream* stream, bool eager_init)
: impl_(stream, IsDefaultSerializationDeterministic(), &cur_),
start_count_(stream->ByteCount()) {
if (eager_init) {
InitEagerly(stream);
}
}
template <class Stream>
inline void CodedOutputStream::InitEagerly(Stream* stream) {
void* data;
int size;
if (PROTOBUF_PREDICT_TRUE(stream->Next(&data, &size) && size > 0)) {
cur_ = impl_.SetInitialBuffer(data, size);
}
}
inline uint8_t* CodedOutputStream::WriteVarint32ToArray(uint32_t value,
uint8_t* target) {
return EpsCopyOutputStream::UnsafeVarint(value, target);
}
inline uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLine(
uint32_t value, uint8_t* target) {
target[0] = static_cast<uint8_t>(value);
if (value < 0x80) {
return target + 1;
} else {
return WriteVarint32ToArrayOutOfLineHelper(value, target);
}
}
inline uint8_t* CodedOutputStream::WriteVarint64ToArray(uint64_t value,
uint8_t* target) {
return EpsCopyOutputStream::UnsafeVarint(value, target);
}
inline void CodedOutputStream::WriteVarint32SignExtended(int32_t value) {
WriteVarint64(static_cast<uint64_t>(value));
}
inline uint8_t* CodedOutputStream::WriteVarint32SignExtendedToArray(
int32_t value, uint8_t* target) {
return WriteVarint64ToArray(static_cast<uint64_t>(value), target);
}
inline uint8_t* CodedOutputStream::WriteLittleEndian32ToArray(uint32_t value,
uint8_t* target) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
memcpy(target, &value, sizeof(value));
#else
target[0] = static_cast<uint8_t>(value);
target[1] = static_cast<uint8_t>(value >> 8);
target[2] = static_cast<uint8_t>(value >> 16);
target[3] = static_cast<uint8_t>(value >> 24);
#endif
return target + sizeof(value);
}
inline uint8_t* CodedOutputStream::WriteLittleEndian64ToArray(uint64_t value,
uint8_t* target) {
#if defined(PROTOBUF_LITTLE_ENDIAN) && \
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
memcpy(target, &value, sizeof(value));
#else
uint32_t part0 = static_cast<uint32_t>(value);
uint32_t part1 = static_cast<uint32_t>(value >> 32);
target[0] = static_cast<uint8_t>(part0);
target[1] = static_cast<uint8_t>(part0 >> 8);
target[2] = static_cast<uint8_t>(part0 >> 16);
target[3] = static_cast<uint8_t>(part0 >> 24);
target[4] = static_cast<uint8_t>(part1);
target[5] = static_cast<uint8_t>(part1 >> 8);
target[6] = static_cast<uint8_t>(part1 >> 16);
target[7] = static_cast<uint8_t>(part1 >> 24);
#endif
return target + sizeof(value);
}
inline void CodedOutputStream::WriteVarint32(uint32_t value) {
cur_ = impl_.EnsureSpace(cur_);
SetCur(WriteVarint32ToArray(value, Cur()));
}
inline void CodedOutputStream::WriteVarint64(uint64_t value) {
cur_ = impl_.EnsureSpace(cur_);
SetCur(WriteVarint64ToArray(value, Cur()));
}
inline void CodedOutputStream::WriteTag(uint32_t value) {
WriteVarint32(value);
}
inline uint8_t* CodedOutputStream::WriteTagToArray(uint32_t value,
uint8_t* target) {
return WriteVarint32ToArray(value, target);
}
inline size_t CodedOutputStream::VarintSize32(uint32_t value) {
// This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
// Use an explicit multiplication to implement the divide of
// a number in the 1..31 range.
// Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
// undefined.
uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
return static_cast<size_t>((log2value * 9 + 73) / 64);
}
inline size_t CodedOutputStream::VarintSize32PlusOne(uint32_t value) {
// Same as above, but one more.
uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
}
inline size_t CodedOutputStream::VarintSize64(uint64_t value) {
// This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
// Use an explicit multiplication to implement the divide of
// a number in the 1..63 range.
// Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
// undefined.
uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
return static_cast<size_t>((log2value * 9 + 73) / 64);
}
inline size_t CodedOutputStream::VarintSize64PlusOne(uint64_t value) {
// Same as above, but one more.
uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
return static_cast<size_t>((log2value * 9 + 73 + 64) / 64);
}
inline size_t CodedOutputStream::VarintSize32SignExtended(int32_t value) {
return VarintSize64(static_cast<uint64_t>(int64_t{value}));
}
inline size_t CodedOutputStream::VarintSize32SignExtendedPlusOne(
int32_t value) {
return VarintSize64PlusOne(static_cast<uint64_t>(int64_t{value}));
}
inline void CodedOutputStream::WriteString(const std::string& str) {
WriteRaw(str.data(), static_cast<int>(str.size()));
}
inline void CodedOutputStream::WriteRawMaybeAliased(const void* data,
int size) {
cur_ = impl_.WriteRawMaybeAliased(data, size, cur_);
}
inline uint8_t* CodedOutputStream::WriteRawToArray(const void* data, int size,
uint8_t* target) {
memcpy(target, data, size);
return target + size;
}
inline uint8_t* CodedOutputStream::WriteStringToArray(const std::string& str,
uint8_t* target) {
return WriteRawToArray(str.data(), static_cast<int>(str.size()), target);
}
} // namespace io
} // namespace protobuf
} // namespace google
#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
#pragma runtime_checks("c", restore)
#endif // _MSC_VER && !defined(__INTEL_COMPILER)
#include <google/protobuf/port_undef.inc>
#endif // GOOGLE_PROTOBUF_IO_CODED_STREAM_H__