1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// http://code.google.com/p/protobuf/ 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31// Authors: wink@google.com (Wink Saville), 32// kenton@google.com (Kenton Varda) 33// Based on original Protocol Buffers design by 34// Sanjay Ghemawat, Jeff Dean, and others. 35// 36// Defines MessageLite, the abstract interface implemented by all (lite 37// and non-lite) protocol message objects. 38 39#ifndef GOOGLE_PROTOBUF_MESSAGE_LITE_H__ 40#define GOOGLE_PROTOBUF_MESSAGE_LITE_H__ 41 42#include <google/protobuf/stubs/common.h> 43#include <google/protobuf/io/coded_stream.h> 44 45namespace google { 46namespace protobuf { 47 48// Interface to light weight protocol messages. 49// 50// This interface is implemented by all protocol message objects. Non-lite 51// messages additionally implement the Message interface, which is a 52// subclass of MessageLite. Use MessageLite instead when you only need 53// the subset of features which it supports -- namely, nothing that uses 54// descriptors or reflection. You can instruct the protocol compiler 55// to generate classes which implement only MessageLite, not the full 56// Message interface, by adding the following line to the .proto file: 57// 58// option optimize_for = LITE_RUNTIME; 59// 60// This is particularly useful on resource-constrained systems where 61// the full protocol buffers runtime library is too big. 62// 63// Note that on non-constrained systems (e.g. servers) when you need 64// to link in lots of protocol definitions, a better way to reduce 65// total code footprint is to use optimize_for = CODE_SIZE. This 66// will make the generated code smaller while still supporting all the 67// same features (at the expense of speed). optimize_for = LITE_RUNTIME 68// is best when you only have a small number of message types linked 69// into your binary, in which case the size of the protocol buffers 70// runtime itself is the biggest problem. 71class LIBPROTOBUF_EXPORT MessageLite { 72 public: 73 inline MessageLite() {} 74 virtual ~MessageLite(); 75 76 // Basic Operations ------------------------------------------------ 77 78 // Get the name of this message type, e.g. "foo.bar.BazProto". 79 virtual string GetTypeName() const = 0; 80 81 // Construct a new instance of the same type. Ownership is passed to the 82 // caller. 83 virtual MessageLite* New() const = 0; 84 85 // Clear all fields of the message and set them to their default values. 86 // Clear() avoids freeing memory, assuming that any memory allocated 87 // to hold parts of the message will be needed again to hold the next 88 // message. If you actually want to free the memory used by a Message, 89 // you must delete it. 90 virtual void Clear() = 0; 91 92 // Quickly check if all required fields have values set. 93 virtual bool IsInitialized() const = 0; 94 95 // This is not implemented for Lite messages -- it just returns "(cannot 96 // determine missing fields for lite message)". However, it is implemented 97 // for full messages. See message.h. 98 virtual string InitializationErrorString() const; 99 100 // If |other| is the exact same class as this, calls MergeFrom(). Otherwise, 101 // results are undefined (probably crash). 102 virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0; 103 104 // Parsing --------------------------------------------------------- 105 // Methods for parsing in protocol buffer format. Most of these are 106 // just simple wrappers around MergeFromCodedStream(). 107 108 // Fill the message with a protocol buffer parsed from the given input 109 // stream. Returns false on a read error or if the input is in the 110 // wrong format. 111 bool ParseFromCodedStream(io::CodedInputStream* input); 112 // Like ParseFromCodedStream(), but accepts messages that are missing 113 // required fields. 114 bool ParsePartialFromCodedStream(io::CodedInputStream* input); 115 // Read a protocol buffer from the given zero-copy input stream. If 116 // successful, the entire input will be consumed. 117 bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input); 118 // Like ParseFromZeroCopyStream(), but accepts messages that are missing 119 // required fields. 120 bool ParsePartialFromZeroCopyStream(io::ZeroCopyInputStream* input); 121 // Read a protocol buffer from the given zero-copy input stream, expecting 122 // the message to be exactly "size" bytes long. If successful, exactly 123 // this many bytes will have been consumed from the input. 124 bool ParseFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size); 125 // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are 126 // missing required fields. 127 bool ParsePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, 128 int size); 129 // Parse a protocol buffer contained in a string. 130 bool ParseFromString(const string& data); 131 // Like ParseFromString(), but accepts messages that are missing 132 // required fields. 133 bool ParsePartialFromString(const string& data); 134 // Parse a protocol buffer contained in an array of bytes. 135 bool ParseFromArray(const void* data, int size); 136 // Like ParseFromArray(), but accepts messages that are missing 137 // required fields. 138 bool ParsePartialFromArray(const void* data, int size); 139 140 141 // Reads a protocol buffer from the stream and merges it into this 142 // Message. Singular fields read from the input overwrite what is 143 // already in the Message and repeated fields are appended to those 144 // already present. 145 // 146 // It is the responsibility of the caller to call input->LastTagWas() 147 // (for groups) or input->ConsumedEntireMessage() (for non-groups) after 148 // this returns to verify that the message's end was delimited correctly. 149 // 150 // ParsefromCodedStream() is implemented as Clear() followed by 151 // MergeFromCodedStream(). 152 bool MergeFromCodedStream(io::CodedInputStream* input); 153 154 // Like MergeFromCodedStream(), but succeeds even if required fields are 155 // missing in the input. 156 // 157 // MergeFromCodedStream() is just implemented as MergePartialFromCodedStream() 158 // followed by IsInitialized(). 159 virtual bool MergePartialFromCodedStream(io::CodedInputStream* input) = 0; 160 161 // Serialization --------------------------------------------------- 162 // Methods for serializing in protocol buffer format. Most of these 163 // are just simple wrappers around ByteSize() and SerializeWithCachedSizes(). 164 165 // Write a protocol buffer of this message to the given output. Returns 166 // false on a write error. If the message is missing required fields, 167 // this may GOOGLE_CHECK-fail. 168 bool SerializeToCodedStream(io::CodedOutputStream* output) const; 169 // Like SerializeToCodedStream(), but allows missing required fields. 170 bool SerializePartialToCodedStream(io::CodedOutputStream* output) const; 171 // Write the message to the given zero-copy output stream. All required 172 // fields must be set. 173 bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const; 174 // Like SerializeToZeroCopyStream(), but allows missing required fields. 175 bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const; 176 // Serialize the message and store it in the given string. All required 177 // fields must be set. 178 bool SerializeToString(string* output) const; 179 // Like SerializeToString(), but allows missing required fields. 180 bool SerializePartialToString(string* output) const; 181 // Serialize the message and store it in the given byte array. All required 182 // fields must be set. 183 bool SerializeToArray(void* data, int size) const; 184 // Like SerializeToArray(), but allows missing required fields. 185 bool SerializePartialToArray(void* data, int size) const; 186 187 // Make a string encoding the message. Is equivalent to calling 188 // SerializeToString() on a string and using that. Returns the empty 189 // string if SerializeToString() would have returned an error. 190 // Note: If you intend to generate many such strings, you may 191 // reduce heap fragmentation by instead re-using the same string 192 // object with calls to SerializeToString(). 193 string SerializeAsString() const; 194 // Like SerializeAsString(), but allows missing required fields. 195 string SerializePartialAsString() const; 196 197 // Like SerializeToString(), but appends to the data to the string's existing 198 // contents. All required fields must be set. 199 bool AppendToString(string* output) const; 200 // Like AppendToString(), but allows missing required fields. 201 bool AppendPartialToString(string* output) const; 202 203 // Computes the serialized size of the message. This recursively calls 204 // ByteSize() on all embedded messages. If a subclass does not override 205 // this, it MUST override SetCachedSize(). 206 virtual int ByteSize() const = 0; 207 208 // Serializes the message without recomputing the size. The message must 209 // not have changed since the last call to ByteSize(); if it has, the results 210 // are undefined. 211 virtual void SerializeWithCachedSizes( 212 io::CodedOutputStream* output) const = 0; 213 214 // Like SerializeWithCachedSizes, but writes directly to *target, returning 215 // a pointer to the byte immediately after the last byte written. "target" 216 // must point at a byte array of at least ByteSize() bytes. 217 virtual uint8* SerializeWithCachedSizesToArray(uint8* target) const; 218 219 // Returns the result of the last call to ByteSize(). An embedded message's 220 // size is needed both to serialize it (because embedded messages are 221 // length-delimited) and to compute the outer message's size. Caching 222 // the size avoids computing it multiple times. 223 // 224 // ByteSize() does not automatically use the cached size when available 225 // because this would require invalidating it every time the message was 226 // modified, which would be too hard and expensive. (E.g. if a deeply-nested 227 // sub-message is changed, all of its parents' cached sizes would need to be 228 // invalidated, which is too much work for an otherwise inlined setter 229 // method.) 230 virtual int GetCachedSize() const = 0; 231 232 private: 233 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite); 234}; 235 236} // namespace protobuf 237 238} // namespace google 239#endif // GOOGLE_PROTOBUF_MESSAGE_LITE_H__ 240