diff options
Diffstat (limited to 'include/google/protobuf/message_lite.h')
| -rw-r--r-- | include/google/protobuf/message_lite.h | 591 |
1 files changed, 0 insertions, 591 deletions
diff --git a/include/google/protobuf/message_lite.h b/include/google/protobuf/message_lite.h deleted file mode 100644 index 950ae1a126..0000000000 --- a/include/google/protobuf/message_lite.h +++ /dev/null @@ -1,591 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Authors: wink@google.com (Wink Saville), -// kenton@google.com (Kenton Varda) -// Based on original Protocol Buffers design by -// Sanjay Ghemawat, Jeff Dean, and others. -// -// Defines MessageLite, the abstract interface implemented by all (lite -// and non-lite) protocol message objects. - -#ifndef GOOGLE_PROTOBUF_MESSAGE_LITE_H__ -#define GOOGLE_PROTOBUF_MESSAGE_LITE_H__ - - -#include <climits> -#include <string> - -#include <google/protobuf/stubs/common.h> -#include <google/protobuf/stubs/logging.h> -#include <google/protobuf/io/coded_stream.h> -#include <google/protobuf/arena.h> -#include <google/protobuf/stubs/once.h> -#include <google/protobuf/port.h> -#include <google/protobuf/stubs/strutil.h> -#include <google/protobuf/explicitly_constructed.h> -#include <google/protobuf/metadata_lite.h> -#include <google/protobuf/stubs/hash.h> // TODO(b/211442718): cleanup - -// clang-format off -#include <google/protobuf/port_def.inc> -// clang-format on - -#ifdef SWIG -#error "You cannot SWIG proto headers" -#endif - -namespace google { -namespace protobuf { - -template <typename T> -class RepeatedPtrField; - -class FastReflectionMessageMutator; -class FastReflectionStringSetter; -class Reflection; - -namespace io { - -class CodedInputStream; -class CodedOutputStream; -class ZeroCopyInputStream; -class ZeroCopyOutputStream; - -} // namespace io -namespace internal { - -class SwapFieldHelper; - -// See parse_context.h for explanation -class ParseContext; - -class ExtensionSet; -class LazyField; -class RepeatedPtrFieldBase; -class TcParser; -class WireFormatLite; -class WeakFieldMap; - -template <typename Type> -class GenericTypeHandler; // defined in repeated_field.h - -// We compute sizes as size_t but cache them as int. This function converts a -// computed size to a cached size. Since we don't proceed with serialization -// if the total size was > INT_MAX, it is not important what this function -// returns for inputs > INT_MAX. However this case should not error or -// GOOGLE_CHECK-fail, because the full size_t resolution is still returned from -// ByteSizeLong() and checked against INT_MAX; we can catch the overflow -// there. -inline int ToCachedSize(size_t size) { return static_cast<int>(size); } - -// We mainly calculate sizes in terms of size_t, but some functions that -// compute sizes return "int". These int sizes are expected to always be -// positive. This function is more efficient than casting an int to size_t -// directly on 64-bit platforms because it avoids making the compiler emit a -// sign extending instruction, which we don't want and don't want to pay for. -inline size_t FromIntSize(int size) { - // Convert to unsigned before widening so sign extension is not necessary. - return static_cast<unsigned int>(size); -} - -// For cases where a legacy function returns an integer size. We GOOGLE_DCHECK() -// that the conversion will fit within an integer; if this is false then we -// are losing information. -inline int ToIntSize(size_t size) { - GOOGLE_DCHECK_LE(size, static_cast<size_t>(INT_MAX)); - return static_cast<int>(size); -} - -// Default empty string object. Don't use this directly. Instead, call -// GetEmptyString() to get the reference. This empty string is aligned with a -// minimum alignment of 8 bytes to match the requirement of ArenaStringPtr. -PROTOBUF_EXPORT extern ExplicitlyConstructedArenaString - fixed_address_empty_string; - - -PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited() { - return fixed_address_empty_string.get(); -} - -PROTOBUF_EXPORT size_t StringSpaceUsedExcludingSelfLong(const std::string& str); - -} // namespace internal - -// Interface to light weight protocol messages. -// -// This interface is implemented by all protocol message objects. Non-lite -// messages additionally implement the Message interface, which is a -// subclass of MessageLite. Use MessageLite instead when you only need -// the subset of features which it supports -- namely, nothing that uses -// descriptors or reflection. You can instruct the protocol compiler -// to generate classes which implement only MessageLite, not the full -// Message interface, by adding the following line to the .proto file: -// -// option optimize_for = LITE_RUNTIME; -// -// This is particularly useful on resource-constrained systems where -// the full protocol buffers runtime library is too big. -// -// Note that on non-constrained systems (e.g. servers) when you need -// to link in lots of protocol definitions, a better way to reduce -// total code footprint is to use optimize_for = CODE_SIZE. This -// will make the generated code smaller while still supporting all the -// same features (at the expense of speed). optimize_for = LITE_RUNTIME -// is best when you only have a small number of message types linked -// into your binary, in which case the size of the protocol buffers -// runtime itself is the biggest problem. -// -// Users must not derive from this class. Only the protocol compiler and -// the internal library are allowed to create subclasses. -class PROTOBUF_EXPORT MessageLite { - public: - constexpr MessageLite() {} - virtual ~MessageLite() = default; - - // Basic Operations ------------------------------------------------ - - // Get the name of this message type, e.g. "foo.bar.BazProto". - virtual std::string GetTypeName() const = 0; - - // Construct a new instance of the same type. Ownership is passed to the - // caller. - MessageLite* New() const { return New(nullptr); } - - // Construct a new instance on the arena. Ownership is passed to the caller - // if arena is a nullptr. - virtual MessageLite* New(Arena* arena) const = 0; - - // Returns user-owned arena; nullptr if it's message owned. - Arena* GetArena() const { return _internal_metadata_.user_arena(); } - - // Clear all fields of the message and set them to their default values. - // Clear() assumes that any memory allocated to hold parts of the message - // will likely be needed again, so the memory used may not be freed. - // To ensure that all memory used by a Message is freed, 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 std::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; - - // These methods return a human-readable summary of the message. Note that - // since the MessageLite interface does not support reflection, there is very - // little information that these methods can provide. They are shadowed by - // methods of the same name on the Message interface which provide much more - // information. The methods here are intended primarily to facilitate code - // reuse for logic that needs to interoperate with both full and lite protos. - // - // The format of the returned string is subject to change, so please do not - // assume it will remain stable over time. - std::string DebugString() const; - std::string ShortDebugString() const { return DebugString(); } - // MessageLite::DebugString is already Utf8 Safe. This is to add compatibility - // with Message. - std::string Utf8DebugString() const { return DebugString(); } - - // Parsing --------------------------------------------------------- - // Methods for parsing in protocol buffer format. Most of these are - // just simple wrappers around MergeFromCodedStream(). Clear() will be - // called before merging the input. - - // 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. A successful return does not indicate the entire input is - // consumed, ensure you call ConsumedEntireMessage() to check that if - // applicable. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromCodedStream( - io::CodedInputStream* input); - // Like ParseFromCodedStream(), but accepts messages that are missing - // required fields. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromCodedStream( - io::CodedInputStream* input); - // Read a protocol buffer from the given zero-copy input stream. If - // successful, the entire input will be consumed. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromZeroCopyStream( - io::ZeroCopyInputStream* input); - // Like ParseFromZeroCopyStream(), but accepts messages that are missing - // required fields. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromZeroCopyStream( - io::ZeroCopyInputStream* input); - // Parse a protocol buffer from a file descriptor. If successful, the entire - // input will be consumed. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromFileDescriptor( - int file_descriptor); - // Like ParseFromFileDescriptor(), but accepts messages that are missing - // required fields. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromFileDescriptor( - int file_descriptor); - // Parse a protocol buffer from a C++ istream. If successful, the entire - // input will be consumed. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromIstream(std::istream* input); - // Like ParseFromIstream(), but accepts messages that are missing - // required fields. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromIstream( - std::istream* 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 MergePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, - int size); - // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are - // missing required fields. - bool MergeFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size); - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromBoundedZeroCopyStream( - io::ZeroCopyInputStream* input, int size); - // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are - // missing required fields. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromBoundedZeroCopyStream( - io::ZeroCopyInputStream* input, int size); - // Parses a protocol buffer contained in a string. Returns true on success. - // This function takes a string in the (non-human-readable) binary wire - // format, matching the encoding output by MessageLite::SerializeToString(). - // If you'd like to convert a human-readable string into a protocol buffer - // object, see google::protobuf::TextFormat::ParseFromString(). - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromString(ConstStringParam data); - // Like ParseFromString(), but accepts messages that are missing - // required fields. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParsePartialFromString( - ConstStringParam data); - // Parse a protocol buffer contained in an array of bytes. - PROTOBUF_ATTRIBUTE_REINITIALIZES bool ParseFromArray(const void* data, - int size); - // Like ParseFromArray(), but accepts messages that are missing - // required fields. - PROTOBUF_ATTRIBUTE_REINITIALIZES 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 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(). - bool MergePartialFromCodedStream(io::CodedInputStream* input); - - // Merge a protocol buffer contained in a string. - bool MergeFromString(ConstStringParam data); - - - // 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(std::string* output) const; - // Like SerializeToString(), but allows missing required fields. - bool SerializePartialToString(std::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(). - std::string SerializeAsString() const; - // Like SerializeAsString(), but allows missing required fields. - std::string SerializePartialAsString() const; - - // Serialize the message and write it to the given file descriptor. All - // required fields must be set. - bool SerializeToFileDescriptor(int file_descriptor) const; - // Like SerializeToFileDescriptor(), but allows missing required fields. - bool SerializePartialToFileDescriptor(int file_descriptor) const; - // Serialize the message and write it to the given C++ ostream. All - // required fields must be set. - bool SerializeToOstream(std::ostream* output) const; - // Like SerializeToOstream(), but allows missing required fields. - bool SerializePartialToOstream(std::ostream* output) const; - - // Like SerializeToString(), but appends to the data to the string's - // existing contents. All required fields must be set. - bool AppendToString(std::string* output) const; - // Like AppendToString(), but allows missing required fields. - bool AppendPartialToString(std::string* output) const; - - - // Computes the serialized size of the message. This recursively calls - // ByteSizeLong() on all embedded messages. - // - // ByteSizeLong() is generally linear in the number of fields defined for the - // proto. - virtual size_t ByteSizeLong() const = 0; - - // Legacy ByteSize() API. - PROTOBUF_DEPRECATED_MSG("Please use ByteSizeLong() instead") - int ByteSize() const { return internal::ToIntSize(ByteSizeLong()); } - - // Serializes the message without recomputing the size. The message must not - // have changed since the last call to ByteSize(), and the value returned by - // ByteSize must be non-negative. Otherwise the results are undefined. - void SerializeWithCachedSizes(io::CodedOutputStream* output) const { - output->SetCur(_InternalSerialize(output->Cur(), output->EpsCopy())); - } - - // Functions below here are not part of the public interface. It isn't - // enforced, but they should be treated as private, and will be private - // at some future time. Unfortunately the implementation of the "friend" - // keyword in GCC is broken at the moment, but we expect it will be fixed. - - // 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. Whether to use - // deterministic serialization, e.g., maps in sorted order, is determined by - // CodedOutputStream::IsDefaultSerializationDeterministic(). - uint8_t* SerializeWithCachedSizesToArray(uint8_t* 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; - - virtual const char* _InternalParse(const char* /*ptr*/, - internal::ParseContext* /*ctx*/) { - return nullptr; - } - - virtual void OnDemandRegisterArenaDtor(Arena* /*arena*/) {} - - protected: - template <typename T> - static T* CreateMaybeMessage(Arena* arena) { - return Arena::CreateMaybeMessage<T>(arena); - } - - inline explicit MessageLite(Arena* arena, bool is_message_owned = false) - : _internal_metadata_(arena, is_message_owned) {} - - // Returns the arena, if any, that directly owns this message and its internal - // memory (Arena::Own is different in that the arena doesn't directly own the - // internal memory). This method is used in proto's implementation for - // swapping, moving and setting allocated, for deciding whether the ownership - // of this message or its internal memory could be changed. - Arena* GetOwningArena() const { return _internal_metadata_.owning_arena(); } - - // Returns the arena, used for allocating internal objects(e.g., child - // messages, etc), or owning incoming objects (e.g., set allocated). - Arena* GetArenaForAllocation() const { return _internal_metadata_.arena(); } - - // Returns true if this message is enabled for message-owned arena (MOA) - // trials. No lite messages are eligible for MOA. - static bool InMoaTrial() { return false; } - - internal::InternalMetadata _internal_metadata_; - - public: - enum ParseFlags { - kMerge = 0, - kParse = 1, - kMergePartial = 2, - kParsePartial = 3, - kMergeWithAliasing = 4, - kParseWithAliasing = 5, - kMergePartialWithAliasing = 6, - kParsePartialWithAliasing = 7 - }; - - template <ParseFlags flags, typename T> - bool ParseFrom(const T& input); - - // Fast path when conditions match (ie. non-deterministic) - // uint8_t* _InternalSerialize(uint8_t* ptr) const; - virtual uint8_t* _InternalSerialize( - uint8_t* ptr, io::EpsCopyOutputStream* stream) const = 0; - - // Identical to IsInitialized() except that it logs an error message. - bool IsInitializedWithErrors() const { - if (IsInitialized()) return true; - LogInitializationErrorMessage(); - return false; - } - - private: - friend class FastReflectionMessageMutator; - friend class FastReflectionStringSetter; - friend class Message; - friend class Reflection; - friend class internal::ExtensionSet; - friend class internal::LazyField; - friend class internal::SwapFieldHelper; - friend class internal::TcParser; - friend class internal::WeakFieldMap; - friend class internal::WireFormatLite; - - template <typename Type> - friend class Arena::InternalHelper; - template <typename Type> - friend class internal::GenericTypeHandler; - - void LogInitializationErrorMessage() const; - - bool MergeFromImpl(io::CodedInputStream* input, ParseFlags parse_flags); - - GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite); -}; - -namespace internal { - -template <bool alias> -bool MergeFromImpl(StringPiece input, MessageLite* msg, - MessageLite::ParseFlags parse_flags); -extern template bool MergeFromImpl<false>(StringPiece input, - MessageLite* msg, - MessageLite::ParseFlags parse_flags); -extern template bool MergeFromImpl<true>(StringPiece input, - MessageLite* msg, - MessageLite::ParseFlags parse_flags); - -template <bool alias> -bool MergeFromImpl(io::ZeroCopyInputStream* input, MessageLite* msg, - MessageLite::ParseFlags parse_flags); -extern template bool MergeFromImpl<false>(io::ZeroCopyInputStream* input, - MessageLite* msg, - MessageLite::ParseFlags parse_flags); -extern template bool MergeFromImpl<true>(io::ZeroCopyInputStream* input, - MessageLite* msg, - MessageLite::ParseFlags parse_flags); - -struct BoundedZCIS { - io::ZeroCopyInputStream* zcis; - int limit; -}; - -template <bool alias> -bool MergeFromImpl(BoundedZCIS input, MessageLite* msg, - MessageLite::ParseFlags parse_flags); -extern template bool MergeFromImpl<false>(BoundedZCIS input, MessageLite* msg, - MessageLite::ParseFlags parse_flags); -extern template bool MergeFromImpl<true>(BoundedZCIS input, MessageLite* msg, - MessageLite::ParseFlags parse_flags); - -template <typename T> -struct SourceWrapper; - -template <bool alias, typename T> -bool MergeFromImpl(const SourceWrapper<T>& input, MessageLite* msg, - MessageLite::ParseFlags parse_flags) { - return input.template MergeInto<alias>(msg, parse_flags); -} - -} // namespace internal - -template <MessageLite::ParseFlags flags, typename T> -bool MessageLite::ParseFrom(const T& input) { - if (flags & kParse) Clear(); - constexpr bool alias = (flags & kMergeWithAliasing) != 0; - return internal::MergeFromImpl<alias>(input, this, flags); -} - -// =================================================================== -// Shutdown support. - - -// Shut down the entire protocol buffers library, deleting all static-duration -// objects allocated by the library or by generated .pb.cc files. -// -// There are two reasons you might want to call this: -// * You use a draconian definition of "memory leak" in which you expect -// every single malloc() to have a corresponding free(), even for objects -// which live until program exit. -// * You are writing a dynamically-loaded library which needs to clean up -// after itself when the library is unloaded. -// -// It is safe to call this multiple times. However, it is not safe to use -// any other part of the protocol buffers library after -// ShutdownProtobufLibrary() has been called. Furthermore this call is not -// thread safe, user needs to synchronize multiple calls. -PROTOBUF_EXPORT void ShutdownProtobufLibrary(); - -namespace internal { - -// Register a function to be called when ShutdownProtocolBuffers() is called. -PROTOBUF_EXPORT void OnShutdown(void (*func)()); -// Run an arbitrary function on an arg -PROTOBUF_EXPORT void OnShutdownRun(void (*f)(const void*), const void* arg); - -template <typename T> -T* OnShutdownDelete(T* p) { - OnShutdownRun([](const void* pp) { delete static_cast<const T*>(pp); }, p); - return p; -} - -} // namespace internal -} // namespace protobuf -} // namespace google - -#include <google/protobuf/port_undef.inc> - -#endif // GOOGLE_PROTOBUF_MESSAGE_LITE_H__ |