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