protobuf 之 MessageLite 接口摘录

摘录下来，方便查看

 

class LIBPROTOBUF_EXPORT MessageLite { public:  inline MessageLite() {}  virtual ~MessageLite();  // Basic Operations ------------------------------------------------  // Get the name of this message type, e.g. "foo.bar.BazProto".  virtual string GetTypeName() const = 0;  // Construct a new instance of the same type.  Ownership is passed to the  // caller.  virtual MessageLite* New() const = 0;  // Clear all fields of the message and set them to their default values.  // Clear() avoids freeing memory, assuming that any memory allocated  // to hold parts of the message will be needed again to hold the next  // message.  If you actually want to free the memory used by a Message,  // you must delete it.  virtual void Clear() = 0;  // Quickly check if all required fields have values set.  virtual bool IsInitialized() const = 0;  // This is not implemented for Lite messages -- it just returns "(cannot  // determine missing fields for lite message)".  However, it is implemented  // for full messages.  See message.h.  virtual string InitializationErrorString() const;  // If |other| is the exact same class as this, calls MergeFrom().  Otherwise,  // results are undefined (probably crash).  virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0;  // Parsing ---------------------------------------------------------  // Methods for parsing in protocol buffer format.  Most of these are  // just simple wrappers around MergeFromCodedStream().  // Fill the message with a protocol buffer parsed from the given input  // stream.  Returns false on a read error or if the input is in the  // wrong format.  bool ParseFromCodedStream(io::CodedInputStream* input);  // Like ParseFromCodedStream(), but accepts messages that are missing  // required fields.  bool ParsePartialFromCodedStream(io::CodedInputStream* input);  // Read a protocol buffer from the given zero-copy input stream.  If  // successful, the entire input will be consumed.  bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);  // Like ParseFromZeroCopyStream(), but accepts messages that are missing  // required fields.  bool ParsePartialFromZeroCopyStream(io::ZeroCopyInputStream* input);  // Read a protocol buffer from the given zero-copy input stream, expecting  // the message to be exactly "size" bytes long.  If successful, exactly  // this many bytes will have been consumed from the input.  bool ParseFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);  // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are  // missing required fields.  bool ParsePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,                                             int size);  // Parse a protocol buffer contained in a string.  bool ParseFromString(const string& data);  // Like ParseFromString(), but accepts messages that are missing  // required fields.  bool ParsePartialFromString(const string& data);  // Parse a protocol buffer contained in an array of bytes.  bool ParseFromArray(const void* data, int size);  // Like ParseFromArray(), but accepts messages that are missing  // required fields.  bool ParsePartialFromArray(const void* data, int size);  // Reads a protocol buffer from the stream and merges it into this  // Message.  Singular fields read from the input overwrite what is  // already in the Message and repeated fields are appended to those  // already present.  //  // It is the responsibility of the caller to call input->LastTagWas()  // (for groups) or input->ConsumedEntireMessage() (for non-groups) after  // this returns to verify that the message's end was delimited correctly.  //  // ParsefromCodedStream() is implemented as Clear() followed by  // MergeFromCodedStream().  bool MergeFromCodedStream(io::CodedInputStream* input);  // Like MergeFromCodedStream(), but succeeds even if required fields are  // missing in the input.  //  // MergeFromCodedStream() is just implemented as MergePartialFromCodedStream()  // followed by IsInitialized().  virtual bool MergePartialFromCodedStream(io::CodedInputStream* input) = 0;  // Serialization ---------------------------------------------------  // Methods for serializing in protocol buffer format.  Most of these  // are just simple wrappers around ByteSize() and SerializeWithCachedSizes().  // Write a protocol buffer of this message to the given output.  Returns  // false on a write error.  If the message is missing required fields,  // this may GOOGLE_CHECK-fail.  bool SerializeToCodedStream(io::CodedOutputStream* output) const;  // Like SerializeToCodedStream(), but allows missing required fields.  bool SerializePartialToCodedStream(io::CodedOutputStream* output) const;  // Write the message to the given zero-copy output stream.  All required  // fields must be set.  bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const;  // Like SerializeToZeroCopyStream(), but allows missing required fields.  bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const;  // Serialize the message and store it in the given string.  All required  // fields must be set.  bool SerializeToString(string* output) const;  // Like SerializeToString(), but allows missing required fields.  bool SerializePartialToString(string* output) const;  // Serialize the message and store it in the given byte array.  All required  // fields must be set.  bool SerializeToArray(void* data, int size) const;  // Like SerializeToArray(), but allows missing required fields.  bool SerializePartialToArray(void* data, int size) const;  // Make a string encoding the message. Is equivalent to calling  // SerializeToString() on a string and using that.  Returns the empty  // string if SerializeToString() would have returned an error.  // Note: If you intend to generate many such strings, you may  // reduce heap fragmentation by instead re-using the same string  // object with calls to SerializeToString().  string SerializeAsString() const;  // Like SerializeAsString(), but allows missing required fields.  string SerializePartialAsString() const;  // Like SerializeToString(), but appends to the data to the string's existing  // contents.  All required fields must be set.  bool AppendToString(string* output) const;  // Like AppendToString(), but allows missing required fields.  bool AppendPartialToString(string* output) const;  // Computes the serialized size of the message.  This recursively calls  // ByteSize() on all embedded messages.  If a subclass does not override  // this, it MUST override SetCachedSize().  virtual int ByteSize() const = 0;  // Serializes the message without recomputing the size.  The message must  // not have changed since the last call to ByteSize(); if it has, the results  // are undefined.  virtual void SerializeWithCachedSizes(      io::CodedOutputStream* output) const = 0;  // Like SerializeWithCachedSizes, but writes directly to *target, returning  // a pointer to the byte immediately after the last byte written.  "target"  // must point at a byte array of at least ByteSize() bytes.  virtual uint8* SerializeWithCachedSizesToArray(uint8* target) const;  // Returns the result of the last call to ByteSize().  An embedded message's  // size is needed both to serialize it (because embedded messages are  // length-delimited) and to compute the outer message's size.  Caching  // the size avoids computing it multiple times.  //  // ByteSize() does not automatically use the cached size when available  // because this would require invalidating it every time the message was  // modified, which would be too hard and expensive.  (E.g. if a deeply-nested  // sub-message is changed, all of its parents' cached sizes would need to be  // invalidated, which is too much work for an otherwise inlined setter  // method.)  virtual int GetCachedSize() const = 0; private:  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite);};