coded_stream.cc | Explore in Territory

// 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: [email protected] (Kenton Varda)
//  Based on original Protocol Buffers design by
//  Sanjay Ghemawat, Jeff Dean, and others.
//
// This implementation is heavily optimized to make reads and writes
// of small values (especially varints) as fast as possible.  In
// particular, we optimize for the common case that a read or a write
// will not cross the end of the buffer, since we can avoid a lot
// of branching in this case.

#include <google/protobuf/io/coded_stream.h>

#include <limits.h>

#include <algorithm>
#include <cstring>
#include <utility>

#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
#include <google/protobuf/stubs/stl_util.h>


// Must be included last.
#include <google/protobuf/port_def.inc>

namespace google {
namespace protobuf {
namespace io {

namespace {

static const int kMaxVarintBytes = …;
static const int kMaxVarint32Bytes = …;


inline bool NextNonEmpty(ZeroCopyInputStream* input, const void** data,
                         int* size) { … }

}  // namespace

// CodedInputStream ==================================================

CodedInputStream::~CodedInputStream() { … }

// Static.
int CodedInputStream::default_recursion_limit_ = …;


void CodedInputStream::BackUpInputToCurrentPosition() { … }

inline void CodedInputStream::RecomputeBufferLimits() { … }

CodedInputStream::Limit CodedInputStream::PushLimit(int byte_limit) { … }

void CodedInputStream::PopLimit(Limit limit) { … }

std::pair<CodedInputStream::Limit, int>
CodedInputStream::IncrementRecursionDepthAndPushLimit(int byte_limit) { … }

CodedInputStream::Limit CodedInputStream::ReadLengthAndPushLimit() { … }

bool CodedInputStream::DecrementRecursionDepthAndPopLimit(Limit limit) { … }

bool CodedInputStream::CheckEntireMessageConsumedAndPopLimit(Limit limit) { … }

int CodedInputStream::BytesUntilLimit() const { … }

void CodedInputStream::SetTotalBytesLimit(int total_bytes_limit) { … }

int CodedInputStream::BytesUntilTotalBytesLimit() const { … }

void CodedInputStream::PrintTotalBytesLimitError() { … }

bool CodedInputStream::SkipFallback(int count, int original_buffer_size) { … }

bool CodedInputStream::GetDirectBufferPointer(const void** data, int* size) { … }

bool CodedInputStream::ReadRaw(void* buffer, int size) { … }

bool CodedInputStream::ReadString(std::string* buffer, int size) { … }

bool CodedInputStream::ReadStringFallback(std::string* buffer, int size) { … }


bool CodedInputStream::ReadLittleEndian32Fallback(uint32_t* value) { … }

bool CodedInputStream::ReadLittleEndian64Fallback(uint64_t* value) { … }

namespace {

// Decodes varint64 with known size, N, and returns next pointer. Knowing N at
// compile time, compiler can generate optimal code. For example, instead of
// subtracting 0x80 at each iteration, it subtracts properly shifted mask once.
template <size_t N>
const uint8_t* DecodeVarint64KnownSize(const uint8_t* buffer, uint64_t* value) { … }

// Read a varint from the given buffer, write it to *value, and return a pair.
// The first part of the pair is true iff the read was successful.  The second
// part is buffer + (number of bytes read).  This function is always inlined,
// so returning a pair is costless.
PROTOBUF_ALWAYS_INLINE
::std::pair<bool, const uint8_t*> ReadVarint32FromArray(uint32_t first_byte,
                                                      const uint8_t* buffer,
                                                      uint32_t* value);
inline ::std::pair<bool, const uint8_t*> ReadVarint32FromArray(
    uint32_t first_byte, const uint8_t* buffer, uint32_t* value) { … }

PROTOBUF_ALWAYS_INLINE::std::pair<bool, const uint8_t*> ReadVarint64FromArray(
    const uint8_t* buffer, uint64_t* value);
inline ::std::pair<bool, const uint8_t*> ReadVarint64FromArray(
    const uint8_t* buffer, uint64_t* value) { … }

}  // namespace

bool CodedInputStream::ReadVarint32Slow(uint32_t* value) { … }

int64_t CodedInputStream::ReadVarint32Fallback(uint32_t first_byte_or_zero) { … }

int CodedInputStream::ReadVarintSizeAsIntSlow() { … }

int CodedInputStream::ReadVarintSizeAsIntFallback() { … }

uint32_t CodedInputStream::ReadTagSlow() { … }

uint32_t CodedInputStream::ReadTagFallback(uint32_t first_byte_or_zero) { … }

bool CodedInputStream::ReadVarint64Slow(uint64_t* value) { … }

std::pair<uint64_t, bool> CodedInputStream::ReadVarint64Fallback() { … }

bool CodedInputStream::Refresh() { … }

// CodedOutputStream =================================================

void EpsCopyOutputStream::EnableAliasing(bool enabled) { … }

int64_t EpsCopyOutputStream::ByteCount(uint8_t* ptr) const { … }

// Flushes what's written out to the underlying ZeroCopyOutputStream buffers.
// Returns the size remaining in the buffer and sets buffer_end_ to the start
// of the remaining buffer, ie. [buffer_end_, buffer_end_ + return value)
int EpsCopyOutputStream::Flush(uint8_t* ptr) { … }

uint8_t* EpsCopyOutputStream::Trim(uint8_t* ptr) { … }


uint8_t* EpsCopyOutputStream::FlushAndResetBuffer(uint8_t* ptr) { … }

bool EpsCopyOutputStream::Skip(int count, uint8_t** pp) { … }

bool EpsCopyOutputStream::GetDirectBufferPointer(void** data, int* size,
                                                 uint8_t** pp) { … }

uint8_t* EpsCopyOutputStream::GetDirectBufferForNBytesAndAdvance(int size,
                                                               uint8_t** pp) { … }

uint8_t* EpsCopyOutputStream::Next() { … }

uint8_t* EpsCopyOutputStream::EnsureSpaceFallback(uint8_t* ptr) { … }

uint8_t* EpsCopyOutputStream::WriteRawFallback(const void* data, int size,
                                             uint8_t* ptr) { … }

uint8_t* EpsCopyOutputStream::WriteAliasedRaw(const void* data, int size,
                                            uint8_t* ptr) { … }

#ifndef PROTOBUF_LITTLE_ENDIAN
uint8_t* EpsCopyOutputStream::WriteRawLittleEndian32(const void* data, int size,
                                                   uint8_t* ptr) {
  auto p = static_cast<const uint8_t*>(data);
  auto end = p + size;
  while (end - p >= kSlopBytes) {
    ptr = EnsureSpace(ptr);
    uint32_t buffer[4];
    static_assert(sizeof(buffer) == kSlopBytes, "Buffer must be kSlopBytes");
    std::memcpy(buffer, p, kSlopBytes);
    p += kSlopBytes;
    for (auto x : buffer)
      ptr = CodedOutputStream::WriteLittleEndian32ToArray(x, ptr);
  }
  while (p < end) {
    ptr = EnsureSpace(ptr);
    uint32_t buffer;
    std::memcpy(&buffer, p, 4);
    p += 4;
    ptr = CodedOutputStream::WriteLittleEndian32ToArray(buffer, ptr);
  }
  return ptr;
}

uint8_t* EpsCopyOutputStream::WriteRawLittleEndian64(const void* data, int size,
                                                   uint8_t* ptr) {
  auto p = static_cast<const uint8_t*>(data);
  auto end = p + size;
  while (end - p >= kSlopBytes) {
    ptr = EnsureSpace(ptr);
    uint64_t buffer[2];
    static_assert(sizeof(buffer) == kSlopBytes, "Buffer must be kSlopBytes");
    std::memcpy(buffer, p, kSlopBytes);
    p += kSlopBytes;
    for (auto x : buffer)
      ptr = CodedOutputStream::WriteLittleEndian64ToArray(x, ptr);
  }
  while (p < end) {
    ptr = EnsureSpace(ptr);
    uint64_t buffer;
    std::memcpy(&buffer, p, 8);
    p += 8;
    ptr = CodedOutputStream::WriteLittleEndian64ToArray(buffer, ptr);
  }
  return ptr;
}
#endif


uint8_t* EpsCopyOutputStream::WriteStringMaybeAliasedOutline(uint32_t num,
                                                           const std::string& s,
                                                           uint8_t* ptr) { … }

uint8_t* EpsCopyOutputStream::WriteStringOutline(uint32_t num, const std::string& s,
                                               uint8_t* ptr) { … }

std::atomic<bool> CodedOutputStream::default_serialization_deterministic_{ … };

CodedOutputStream::~CodedOutputStream() { … }


uint8_t* CodedOutputStream::WriteStringWithSizeToArray(const std::string& str,
                                                     uint8_t* target) { … }

uint8_t* CodedOutputStream::WriteVarint32ToArrayOutOfLineHelper(uint32_t value,
                                                              uint8_t* target) { … }

}  // namespace io
}  // namespace protobuf
}  // namespace google

#include <google/protobuf/port_undef.inc>
chromium/third_party/protobuf/src/google/protobuf/io/coded_stream.cc
