1235 lines
40 KiB
C++
1235 lines
40 KiB
C++
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
// http://code.google.com/p/protobuf/
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
// Author: kenton@google.com (Kenton Varda) and others
|
|
//
|
|
// Contains basic types and utilities used by the rest of the library.
|
|
|
|
#ifndef GOOGLE_PROTOBUF_COMMON_H__
|
|
#define GOOGLE_PROTOBUF_COMMON_H__
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <cstddef>
|
|
#include <string>
|
|
#include <string.h>
|
|
#if defined(__osf__)
|
|
// Tru64 lacks stdint.h, but has inttypes.h which defines a superset of
|
|
// what stdint.h would define.
|
|
#include <inttypes.h>
|
|
#elif !defined(_MSC_VER)
|
|
#include <stdint.h>
|
|
#endif
|
|
#include <algorithm>
|
|
|
|
using std::min;
|
|
using std::max;
|
|
|
|
// make MSVC shut up about some things
|
|
#ifdef _MSC_VER
|
|
// don't spew nonsense!
|
|
#pragma warning( disable: 4251 )
|
|
// POSIX is OK, stop complaining.
|
|
#pragma warning( disable: 4996 )
|
|
// using 'this' in initializer lists...
|
|
#pragma warning( disable: 4355 )
|
|
// signed/unsigned mismatch
|
|
#pragma warning( disable: 4018 )
|
|
// possible loss of data from assignments between different numeric types
|
|
#pragma warning( disable: 4244 )
|
|
// forcing value to 'bool'
|
|
#pragma warning( disable: 4800 )
|
|
#endif
|
|
|
|
#if defined(_MSC_VER) && defined(_CPPUNWIND)
|
|
#define PROTOBUF_USE_EXCEPTIONS
|
|
#elif defined(__EXCEPTIONS)
|
|
#define PROTOBUF_USE_EXCEPTIONS
|
|
#endif
|
|
#ifdef PROTOBUF_USE_EXCEPTIONS
|
|
#include <exception>
|
|
#endif
|
|
|
|
#if defined(_WIN32) && defined(GetMessage)
|
|
// Allow GetMessage to be used as a valid method name in protobuf classes.
|
|
// windows.h defines GetMessage() as a macro. Let's re-define it as an inline
|
|
// function. The inline function should be equivalent for C++ users.
|
|
inline BOOL GetMessage_Win32(
|
|
LPMSG lpMsg, HWND hWnd,
|
|
UINT wMsgFilterMin, UINT wMsgFilterMax) {
|
|
return GetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
|
|
}
|
|
#undef GetMessage
|
|
inline BOOL GetMessage(
|
|
LPMSG lpMsg, HWND hWnd,
|
|
UINT wMsgFilterMin, UINT wMsgFilterMax) {
|
|
return GetMessage_Win32(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
|
|
}
|
|
#endif
|
|
|
|
|
|
namespace std {}
|
|
|
|
namespace google {
|
|
namespace protobuf {
|
|
|
|
#undef GOOGLE_DISALLOW_EVIL_CONSTRUCTORS
|
|
#define GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeName) \
|
|
TypeName(const TypeName&); \
|
|
void operator=(const TypeName&)
|
|
|
|
#if defined(_MSC_VER) && defined(PROTOBUF_USE_DLLS)
|
|
#ifdef LIBPROTOBUF_EXPORTS
|
|
#define LIBPROTOBUF_EXPORT __declspec(dllexport)
|
|
#else
|
|
#define LIBPROTOBUF_EXPORT __declspec(dllimport)
|
|
#endif
|
|
#ifdef LIBPROTOC_EXPORTS
|
|
#define LIBPROTOC_EXPORT __declspec(dllexport)
|
|
#else
|
|
#define LIBPROTOC_EXPORT __declspec(dllimport)
|
|
#endif
|
|
#elif defined(PROTOBUF_USE_DLLS)
|
|
#define LIBPROTOBUF_EXPORT __attribute__ ((visibility("default")))
|
|
#define LIBPROTOC_EXPORT __attribute__ ((visibility("default")))
|
|
#else
|
|
#define LIBPROTOBUF_EXPORT
|
|
#define LIBPROTOC_EXPORT
|
|
#endif
|
|
|
|
namespace internal {
|
|
|
|
// Some of these constants are macros rather than const ints so that they can
|
|
// be used in #if directives.
|
|
|
|
// The current version, represented as a single integer to make comparison
|
|
// easier: major * 10^6 + minor * 10^3 + micro
|
|
#define GOOGLE_PROTOBUF_VERSION 2004001
|
|
|
|
// The minimum library version which works with the current version of the
|
|
// headers.
|
|
#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 2004000
|
|
|
|
// The minimum header version which works with the current version of
|
|
// the library. This constant should only be used by protoc's C++ code
|
|
// generator.
|
|
static const int kMinHeaderVersionForLibrary = 2004000;
|
|
|
|
// The minimum protoc version which works with the current version of the
|
|
// headers.
|
|
#define GOOGLE_PROTOBUF_MIN_PROTOC_VERSION 2004000
|
|
|
|
// The minimum header version which works with the current version of
|
|
// protoc. This constant should only be used in VerifyVersion().
|
|
static const int kMinHeaderVersionForProtoc = 2004000;
|
|
|
|
// Verifies that the headers and libraries are compatible. Use the macro
|
|
// below to call this.
|
|
void LIBPROTOBUF_EXPORT VerifyVersion(int headerVersion, int minLibraryVersion,
|
|
const char* filename);
|
|
|
|
// Converts a numeric version number to a string.
|
|
std::string LIBPROTOBUF_EXPORT VersionString(int version);
|
|
|
|
} // namespace internal
|
|
|
|
// Place this macro in your main() function (or somewhere before you attempt
|
|
// to use the protobuf library) to verify that the version you link against
|
|
// matches the headers you compiled against. If a version mismatch is
|
|
// detected, the process will abort.
|
|
#define GOOGLE_PROTOBUF_VERIFY_VERSION \
|
|
::google::protobuf::internal::VerifyVersion( \
|
|
GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION, \
|
|
__FILE__)
|
|
|
|
// ===================================================================
|
|
// from google3/base/port.h
|
|
|
|
typedef unsigned int uint;
|
|
|
|
#ifdef _MSC_VER
|
|
typedef __int8 int8;
|
|
typedef __int16 int16;
|
|
typedef __int32 int32;
|
|
typedef __int64 int64;
|
|
|
|
typedef unsigned __int8 uint8;
|
|
typedef unsigned __int16 uint16;
|
|
typedef unsigned __int32 uint32;
|
|
typedef unsigned __int64 uint64;
|
|
#else
|
|
typedef int8_t int8;
|
|
typedef int16_t int16;
|
|
typedef int32_t int32;
|
|
typedef int64_t int64;
|
|
|
|
typedef uint8_t uint8;
|
|
typedef uint16_t uint16;
|
|
typedef uint32_t uint32;
|
|
typedef uint64_t uint64;
|
|
#endif
|
|
|
|
// long long macros to be used because gcc and vc++ use different suffixes,
|
|
// and different size specifiers in format strings
|
|
#undef GOOGLE_LONGLONG
|
|
#undef GOOGLE_ULONGLONG
|
|
#undef GOOGLE_LL_FORMAT
|
|
|
|
#ifdef _MSC_VER
|
|
#define GOOGLE_LONGLONG(x) x##I64
|
|
#define GOOGLE_ULONGLONG(x) x##UI64
|
|
#define GOOGLE_LL_FORMAT "I64" // As in printf("%I64d", ...)
|
|
#else
|
|
#define GOOGLE_LONGLONG(x) x##LL
|
|
#define GOOGLE_ULONGLONG(x) x##ULL
|
|
#define GOOGLE_LL_FORMAT "ll" // As in "%lld". Note that "q" is poor form also.
|
|
#endif
|
|
|
|
static const int32 kint32max = 0x7FFFFFFF;
|
|
static const int32 kint32min = -kint32max - 1;
|
|
static const int64 kint64max = GOOGLE_LONGLONG(0x7FFFFFFFFFFFFFFF);
|
|
static const int64 kint64min = -kint64max - 1;
|
|
static const uint32 kuint32max = 0xFFFFFFFFu;
|
|
static const uint64 kuint64max = GOOGLE_ULONGLONG(0xFFFFFFFFFFFFFFFF);
|
|
|
|
// -------------------------------------------------------------------
|
|
// Annotations: Some parts of the code have been annotated in ways that might
|
|
// be useful to some compilers or tools, but are not supported universally.
|
|
// You can #define these annotations yourself if the default implementation
|
|
// is not right for you.
|
|
|
|
#ifndef GOOGLE_ATTRIBUTE_ALWAYS_INLINE
|
|
#if defined(__GNUC__) && (__GNUC__ > 3 ||(__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
|
|
// For functions we want to force inline.
|
|
// Introduced in gcc 3.1.
|
|
#define GOOGLE_ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline))
|
|
#else
|
|
// Other compilers will have to figure it out for themselves.
|
|
#define GOOGLE_ATTRIBUTE_ALWAYS_INLINE
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef GOOGLE_ATTRIBUTE_DEPRECATED
|
|
#ifdef __GNUC__
|
|
// If the method/variable/type is used anywhere, produce a warning.
|
|
#define GOOGLE_ATTRIBUTE_DEPRECATED __attribute__((deprecated))
|
|
#else
|
|
#define GOOGLE_ATTRIBUTE_DEPRECATED
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef GOOGLE_PREDICT_TRUE
|
|
#ifdef __GNUC__
|
|
// Provided at least since GCC 3.0.
|
|
#define GOOGLE_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
|
|
#else
|
|
#define GOOGLE_PREDICT_TRUE
|
|
#endif
|
|
#endif
|
|
|
|
// Delimits a block of code which may write to memory which is simultaneously
|
|
// written by other threads, but which has been determined to be thread-safe
|
|
// (e.g. because it is an idempotent write).
|
|
#ifndef GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN
|
|
#define GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN()
|
|
#endif
|
|
#ifndef GOOGLE_SAFE_CONCURRENT_WRITES_END
|
|
#define GOOGLE_SAFE_CONCURRENT_WRITES_END()
|
|
#endif
|
|
|
|
// ===================================================================
|
|
// from google3/base/basictypes.h
|
|
|
|
// The GOOGLE_ARRAYSIZE(arr) macro returns the # of elements in an array arr.
|
|
// The expression is a compile-time constant, and therefore can be
|
|
// used in defining new arrays, for example.
|
|
//
|
|
// GOOGLE_ARRAYSIZE catches a few type errors. If you see a compiler error
|
|
//
|
|
// "warning: division by zero in ..."
|
|
//
|
|
// when using GOOGLE_ARRAYSIZE, you are (wrongfully) giving it a pointer.
|
|
// You should only use GOOGLE_ARRAYSIZE on statically allocated arrays.
|
|
//
|
|
// The following comments are on the implementation details, and can
|
|
// be ignored by the users.
|
|
//
|
|
// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
|
|
// the array) and sizeof(*(arr)) (the # of bytes in one array
|
|
// element). If the former is divisible by the latter, perhaps arr is
|
|
// indeed an array, in which case the division result is the # of
|
|
// elements in the array. Otherwise, arr cannot possibly be an array,
|
|
// and we generate a compiler error to prevent the code from
|
|
// compiling.
|
|
//
|
|
// Since the size of bool is implementation-defined, we need to cast
|
|
// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
|
|
// result has type size_t.
|
|
//
|
|
// This macro is not perfect as it wrongfully accepts certain
|
|
// pointers, namely where the pointer size is divisible by the pointee
|
|
// size. Since all our code has to go through a 32-bit compiler,
|
|
// where a pointer is 4 bytes, this means all pointers to a type whose
|
|
// size is 3 or greater than 4 will be (righteously) rejected.
|
|
//
|
|
// Kudos to Jorg Brown for this simple and elegant implementation.
|
|
|
|
#undef GOOGLE_ARRAYSIZE
|
|
#define GOOGLE_ARRAYSIZE(a) \
|
|
((sizeof(a) / sizeof(*(a))) / \
|
|
static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
|
|
|
|
namespace internal {
|
|
|
|
// Use implicit_cast as a safe version of static_cast or const_cast
|
|
// for upcasting in the type hierarchy (i.e. casting a pointer to Foo
|
|
// to a pointer to SuperclassOfFoo or casting a pointer to Foo to
|
|
// a const pointer to Foo).
|
|
// When you use implicit_cast, the compiler checks that the cast is safe.
|
|
// Such explicit implicit_casts are necessary in surprisingly many
|
|
// situations where C++ demands an exact type match instead of an
|
|
// argument type convertable to a target type.
|
|
//
|
|
// The From type can be inferred, so the preferred syntax for using
|
|
// implicit_cast is the same as for static_cast etc.:
|
|
//
|
|
// implicit_cast<ToType>(expr)
|
|
//
|
|
// implicit_cast would have been part of the C++ standard library,
|
|
// but the proposal was submitted too late. It will probably make
|
|
// its way into the language in the future.
|
|
template<typename To, typename From>
|
|
inline To implicit_cast(From const &f) {
|
|
return f;
|
|
}
|
|
|
|
// When you upcast (that is, cast a pointer from type Foo to type
|
|
// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts
|
|
// always succeed. When you downcast (that is, cast a pointer from
|
|
// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
|
|
// how do you know the pointer is really of type SubclassOfFoo? It
|
|
// could be a bare Foo, or of type DifferentSubclassOfFoo. Thus,
|
|
// when you downcast, you should use this macro. In debug mode, we
|
|
// use dynamic_cast<> to double-check the downcast is legal (we die
|
|
// if it's not). In normal mode, we do the efficient static_cast<>
|
|
// instead. Thus, it's important to test in debug mode to make sure
|
|
// the cast is legal!
|
|
// This is the only place in the code we should use dynamic_cast<>.
|
|
// In particular, you SHOULDN'T be using dynamic_cast<> in order to
|
|
// do RTTI (eg code like this:
|
|
// if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
|
|
// if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
|
|
// You should design the code some other way not to need this.
|
|
|
|
template<typename To, typename From> // use like this: down_cast<T*>(foo);
|
|
inline To down_cast(From* f) { // so we only accept pointers
|
|
// Ensures that To is a sub-type of From *. This test is here only
|
|
// for compile-time type checking, and has no overhead in an
|
|
// optimized build at run-time, as it will be optimized away
|
|
// completely.
|
|
if (false) {
|
|
implicit_cast<From*, To>(0);
|
|
}
|
|
|
|
#if !defined(NDEBUG) && !defined(GOOGLE_PROTOBUF_NO_RTTI)
|
|
assert(f == NULL || dynamic_cast<To>(f) != NULL); // RTTI: debug mode only!
|
|
#endif
|
|
return static_cast<To>(f);
|
|
}
|
|
|
|
} // namespace internal
|
|
|
|
// We made these internal so that they would show up as such in the docs,
|
|
// but we don't want to stick "internal::" in front of them everywhere.
|
|
using internal::implicit_cast;
|
|
using internal::down_cast;
|
|
|
|
// The COMPILE_ASSERT macro can be used to verify that a compile time
|
|
// expression is true. For example, you could use it to verify the
|
|
// size of a static array:
|
|
//
|
|
// COMPILE_ASSERT(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
|
|
// content_type_names_incorrect_size);
|
|
//
|
|
// or to make sure a struct is smaller than a certain size:
|
|
//
|
|
// COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
|
|
//
|
|
// The second argument to the macro is the name of the variable. If
|
|
// the expression is false, most compilers will issue a warning/error
|
|
// containing the name of the variable.
|
|
|
|
namespace internal {
|
|
|
|
template <bool>
|
|
struct CompileAssert {
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
#undef GOOGLE_COMPILE_ASSERT
|
|
#define GOOGLE_COMPILE_ASSERT(expr, msg) \
|
|
typedef ::google::protobuf::internal::CompileAssert<(bool(expr))> \
|
|
msg[bool(expr) ? 1 : -1]
|
|
|
|
|
|
// Implementation details of COMPILE_ASSERT:
|
|
//
|
|
// - COMPILE_ASSERT works by defining an array type that has -1
|
|
// elements (and thus is invalid) when the expression is false.
|
|
//
|
|
// - The simpler definition
|
|
//
|
|
// #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
|
|
//
|
|
// does not work, as gcc supports variable-length arrays whose sizes
|
|
// are determined at run-time (this is gcc's extension and not part
|
|
// of the C++ standard). As a result, gcc fails to reject the
|
|
// following code with the simple definition:
|
|
//
|
|
// int foo;
|
|
// COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
|
|
// // not a compile-time constant.
|
|
//
|
|
// - By using the type CompileAssert<(bool(expr))>, we ensures that
|
|
// expr is a compile-time constant. (Template arguments must be
|
|
// determined at compile-time.)
|
|
//
|
|
// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
|
|
// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written
|
|
//
|
|
// CompileAssert<bool(expr)>
|
|
//
|
|
// instead, these compilers will refuse to compile
|
|
//
|
|
// COMPILE_ASSERT(5 > 0, some_message);
|
|
//
|
|
// (They seem to think the ">" in "5 > 0" marks the end of the
|
|
// template argument list.)
|
|
//
|
|
// - The array size is (bool(expr) ? 1 : -1), instead of simply
|
|
//
|
|
// ((expr) ? 1 : -1).
|
|
//
|
|
// This is to avoid running into a bug in MS VC 7.1, which
|
|
// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
|
|
|
|
// ===================================================================
|
|
// from google3/base/scoped_ptr.h
|
|
|
|
namespace internal {
|
|
|
|
// This is an implementation designed to match the anticipated future TR2
|
|
// implementation of the scoped_ptr class, and its closely-related brethren,
|
|
// scoped_array, scoped_ptr_malloc, and make_scoped_ptr.
|
|
|
|
template <class C> class scoped_ptr;
|
|
template <class C> class scoped_array;
|
|
|
|
// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
|
|
// automatically deletes the pointer it holds (if any).
|
|
// That is, scoped_ptr<T> owns the T object that it points to.
|
|
// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
|
|
//
|
|
// The size of a scoped_ptr is small:
|
|
// sizeof(scoped_ptr<C>) == sizeof(C*)
|
|
template <class C>
|
|
class scoped_ptr {
|
|
public:
|
|
|
|
// The element type
|
|
typedef C element_type;
|
|
|
|
// Constructor. Defaults to intializing with NULL.
|
|
// There is no way to create an uninitialized scoped_ptr.
|
|
// The input parameter must be allocated with new.
|
|
explicit scoped_ptr(C* p = NULL) : ptr_(p) { }
|
|
|
|
// Destructor. If there is a C object, delete it.
|
|
// We don't need to test ptr_ == NULL because C++ does that for us.
|
|
~scoped_ptr() {
|
|
enum { type_must_be_complete = sizeof(C) };
|
|
delete ptr_;
|
|
}
|
|
|
|
// Reset. Deletes the current owned object, if any.
|
|
// Then takes ownership of a new object, if given.
|
|
// this->reset(this->get()) works.
|
|
void reset(C* p = NULL) {
|
|
if (p != ptr_) {
|
|
enum { type_must_be_complete = sizeof(C) };
|
|
delete ptr_;
|
|
ptr_ = p;
|
|
}
|
|
}
|
|
|
|
// Accessors to get the owned object.
|
|
// operator* and operator-> will assert() if there is no current object.
|
|
C& operator*() const {
|
|
assert(ptr_ != NULL);
|
|
return *ptr_;
|
|
}
|
|
C* operator->() const {
|
|
assert(ptr_ != NULL);
|
|
return ptr_;
|
|
}
|
|
C* get() const { return ptr_; }
|
|
|
|
// Comparison operators.
|
|
// These return whether two scoped_ptr refer to the same object, not just to
|
|
// two different but equal objects.
|
|
bool operator==(C* p) const { return ptr_ == p; }
|
|
bool operator!=(C* p) const { return ptr_ != p; }
|
|
|
|
// Swap two scoped pointers.
|
|
void swap(scoped_ptr& p2) {
|
|
C* tmp = ptr_;
|
|
ptr_ = p2.ptr_;
|
|
p2.ptr_ = tmp;
|
|
}
|
|
|
|
// Release a pointer.
|
|
// The return value is the current pointer held by this object.
|
|
// If this object holds a NULL pointer, the return value is NULL.
|
|
// After this operation, this object will hold a NULL pointer,
|
|
// and will not own the object any more.
|
|
C* release() {
|
|
C* retVal = ptr_;
|
|
ptr_ = NULL;
|
|
return retVal;
|
|
}
|
|
|
|
private:
|
|
C* ptr_;
|
|
|
|
// Forbid comparison of scoped_ptr types. If C2 != C, it totally doesn't
|
|
// make sense, and if C2 == C, it still doesn't make sense because you should
|
|
// never have the same object owned by two different scoped_ptrs.
|
|
template <class C2> bool operator==(scoped_ptr<C2> const& p2) const;
|
|
template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const;
|
|
|
|
// Disallow evil constructors
|
|
scoped_ptr(const scoped_ptr&);
|
|
void operator=(const scoped_ptr&);
|
|
};
|
|
|
|
// scoped_array<C> is like scoped_ptr<C>, except that the caller must allocate
|
|
// with new [] and the destructor deletes objects with delete [].
|
|
//
|
|
// As with scoped_ptr<C>, a scoped_array<C> either points to an object
|
|
// or is NULL. A scoped_array<C> owns the object that it points to.
|
|
//
|
|
// Size: sizeof(scoped_array<C>) == sizeof(C*)
|
|
template <class C>
|
|
class scoped_array {
|
|
public:
|
|
|
|
// The element type
|
|
typedef C element_type;
|
|
|
|
// Constructor. Defaults to intializing with NULL.
|
|
// There is no way to create an uninitialized scoped_array.
|
|
// The input parameter must be allocated with new [].
|
|
explicit scoped_array(C* p = NULL) : array_(p) { }
|
|
|
|
// Destructor. If there is a C object, delete it.
|
|
// We don't need to test ptr_ == NULL because C++ does that for us.
|
|
~scoped_array() {
|
|
enum { type_must_be_complete = sizeof(C) };
|
|
delete[] array_;
|
|
}
|
|
|
|
// Reset. Deletes the current owned object, if any.
|
|
// Then takes ownership of a new object, if given.
|
|
// this->reset(this->get()) works.
|
|
void reset(C* p = NULL) {
|
|
if (p != array_) {
|
|
enum { type_must_be_complete = sizeof(C) };
|
|
delete[] array_;
|
|
array_ = p;
|
|
}
|
|
}
|
|
|
|
// Get one element of the current object.
|
|
// Will assert() if there is no current object, or index i is negative.
|
|
C& operator[](std::ptrdiff_t i) const {
|
|
assert(i >= 0);
|
|
assert(array_ != NULL);
|
|
return array_[i];
|
|
}
|
|
|
|
// Get a pointer to the zeroth element of the current object.
|
|
// If there is no current object, return NULL.
|
|
C* get() const {
|
|
return array_;
|
|
}
|
|
|
|
// Comparison operators.
|
|
// These return whether two scoped_array refer to the same object, not just to
|
|
// two different but equal objects.
|
|
bool operator==(C* p) const { return array_ == p; }
|
|
bool operator!=(C* p) const { return array_ != p; }
|
|
|
|
// Swap two scoped arrays.
|
|
void swap(scoped_array& p2) {
|
|
C* tmp = array_;
|
|
array_ = p2.array_;
|
|
p2.array_ = tmp;
|
|
}
|
|
|
|
// Release an array.
|
|
// The return value is the current pointer held by this object.
|
|
// If this object holds a NULL pointer, the return value is NULL.
|
|
// After this operation, this object will hold a NULL pointer,
|
|
// and will not own the object any more.
|
|
C* release() {
|
|
C* retVal = array_;
|
|
array_ = NULL;
|
|
return retVal;
|
|
}
|
|
|
|
private:
|
|
C* array_;
|
|
|
|
// Forbid comparison of different scoped_array types.
|
|
template <class C2> bool operator==(scoped_array<C2> const& p2) const;
|
|
template <class C2> bool operator!=(scoped_array<C2> const& p2) const;
|
|
|
|
// Disallow evil constructors
|
|
scoped_array(const scoped_array&);
|
|
void operator=(const scoped_array&);
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
// We made these internal so that they would show up as such in the docs,
|
|
// but we don't want to stick "internal::" in front of them everywhere.
|
|
using internal::scoped_ptr;
|
|
using internal::scoped_array;
|
|
|
|
// ===================================================================
|
|
// emulates google3/base/logging.h
|
|
|
|
enum LogLevel {
|
|
LOGLEVEL_INFO, // Informational. This is never actually used by
|
|
// libprotobuf.
|
|
LOGLEVEL_WARNING, // Warns about issues that, although not technically a
|
|
// problem now, could cause problems in the future. For
|
|
// example, a // warning will be printed when parsing a
|
|
// message that is near the message size limit.
|
|
LOGLEVEL_ERROR, // An error occurred which should never happen during
|
|
// normal use.
|
|
LOGLEVEL_FATAL, // An error occurred from which the library cannot
|
|
// recover. This usually indicates a programming error
|
|
// in the code which calls the library, especially when
|
|
// compiled in debug mode.
|
|
|
|
#ifdef NDEBUG
|
|
LOGLEVEL_DFATAL = LOGLEVEL_ERROR
|
|
#else
|
|
LOGLEVEL_DFATAL = LOGLEVEL_FATAL
|
|
#endif
|
|
};
|
|
|
|
namespace internal {
|
|
|
|
class LogFinisher;
|
|
|
|
class LIBPROTOBUF_EXPORT LogMessage {
|
|
public:
|
|
LogMessage(LogLevel level, const char* filename, int line);
|
|
~LogMessage();
|
|
|
|
LogMessage& operator<<(const std::string& value);
|
|
LogMessage& operator<<(const char* value);
|
|
LogMessage& operator<<(char value);
|
|
LogMessage& operator<<(int value);
|
|
LogMessage& operator<<(uint value);
|
|
LogMessage& operator<<(long value);
|
|
LogMessage& operator<<(unsigned long value);
|
|
LogMessage& operator<<(double value);
|
|
|
|
private:
|
|
friend class LogFinisher;
|
|
void Finish();
|
|
|
|
LogLevel level_;
|
|
const char* filename_;
|
|
int line_;
|
|
std::string message_;
|
|
};
|
|
|
|
// Used to make the entire "LOG(BLAH) << etc." expression have a void return
|
|
// type and print a newline after each message.
|
|
class LIBPROTOBUF_EXPORT LogFinisher {
|
|
public:
|
|
void operator=(LogMessage& other);
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
// Undef everything in case we're being mixed with some other Google library
|
|
// which already defined them itself. Presumably all Google libraries will
|
|
// support the same syntax for these so it should not be a big deal if they
|
|
// end up using our definitions instead.
|
|
#undef GOOGLE_LOG
|
|
#undef GOOGLE_LOG_IF
|
|
|
|
#undef GOOGLE_CHECK
|
|
#undef GOOGLE_CHECK_EQ
|
|
#undef GOOGLE_CHECK_NE
|
|
#undef GOOGLE_CHECK_LT
|
|
#undef GOOGLE_CHECK_LE
|
|
#undef GOOGLE_CHECK_GT
|
|
#undef GOOGLE_CHECK_GE
|
|
|
|
#undef GOOGLE_DLOG
|
|
#undef GOOGLE_DCHECK
|
|
#undef GOOGLE_DCHECK_EQ
|
|
#undef GOOGLE_DCHECK_NE
|
|
#undef GOOGLE_DCHECK_LT
|
|
#undef GOOGLE_DCHECK_LE
|
|
#undef GOOGLE_DCHECK_GT
|
|
#undef GOOGLE_DCHECK_GE
|
|
|
|
#define GOOGLE_LOG(LEVEL) \
|
|
::google::protobuf::internal::LogFinisher() = \
|
|
::google::protobuf::internal::LogMessage( \
|
|
::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
|
|
#define GOOGLE_LOG_IF(LEVEL, CONDITION) \
|
|
!(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
|
|
|
|
#define GOOGLE_CHECK(EXPRESSION) \
|
|
GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
|
|
#define GOOGLE_CHECK_EQ(A, B) GOOGLE_CHECK((A) == (B))
|
|
#define GOOGLE_CHECK_NE(A, B) GOOGLE_CHECK((A) != (B))
|
|
#define GOOGLE_CHECK_LT(A, B) GOOGLE_CHECK((A) < (B))
|
|
#define GOOGLE_CHECK_LE(A, B) GOOGLE_CHECK((A) <= (B))
|
|
#define GOOGLE_CHECK_GT(A, B) GOOGLE_CHECK((A) > (B))
|
|
#define GOOGLE_CHECK_GE(A, B) GOOGLE_CHECK((A) >= (B))
|
|
|
|
#ifdef NDEBUG
|
|
|
|
#define GOOGLE_DLOG GOOGLE_LOG_IF(INFO, false)
|
|
|
|
#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
|
|
#define GOOGLE_DCHECK_EQ(A, B) GOOGLE_DCHECK((A) == (B))
|
|
#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
|
|
#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) < (B))
|
|
#define GOOGLE_DCHECK_LE(A, B) GOOGLE_DCHECK((A) <= (B))
|
|
#define GOOGLE_DCHECK_GT(A, B) GOOGLE_DCHECK((A) > (B))
|
|
#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
|
|
|
|
#else // NDEBUG
|
|
|
|
#define GOOGLE_DLOG GOOGLE_LOG
|
|
|
|
#define GOOGLE_DCHECK GOOGLE_CHECK
|
|
#define GOOGLE_DCHECK_EQ GOOGLE_CHECK_EQ
|
|
#define GOOGLE_DCHECK_NE GOOGLE_CHECK_NE
|
|
#define GOOGLE_DCHECK_LT GOOGLE_CHECK_LT
|
|
#define GOOGLE_DCHECK_LE GOOGLE_CHECK_LE
|
|
#define GOOGLE_DCHECK_GT GOOGLE_CHECK_GT
|
|
#define GOOGLE_DCHECK_GE GOOGLE_CHECK_GE
|
|
|
|
#endif // !NDEBUG
|
|
|
|
typedef void LogHandler(LogLevel level, const char* filename, int line,
|
|
const std::string& message);
|
|
|
|
// The protobuf library sometimes writes warning and error messages to
|
|
// stderr. These messages are primarily useful for developers, but may
|
|
// also help end users figure out a problem. If you would prefer that
|
|
// these messages be sent somewhere other than stderr, call SetLogHandler()
|
|
// to set your own handler. This returns the old handler. Set the handler
|
|
// to NULL to ignore log messages (but see also LogSilencer, below).
|
|
//
|
|
// Obviously, SetLogHandler is not thread-safe. You should only call it
|
|
// at initialization time, and probably not from library code. If you
|
|
// simply want to suppress log messages temporarily (e.g. because you
|
|
// have some code that tends to trigger them frequently and you know
|
|
// the warnings are not important to you), use the LogSilencer class
|
|
// below.
|
|
LIBPROTOBUF_EXPORT LogHandler* SetLogHandler(LogHandler* new_func);
|
|
|
|
// Create a LogSilencer if you want to temporarily suppress all log
|
|
// messages. As long as any LogSilencer objects exist, non-fatal
|
|
// log messages will be discarded (the current LogHandler will *not*
|
|
// be called). Constructing a LogSilencer is thread-safe. You may
|
|
// accidentally suppress log messages occurring in another thread, but
|
|
// since messages are generally for debugging purposes only, this isn't
|
|
// a big deal. If you want to intercept log messages, use SetLogHandler().
|
|
class LIBPROTOBUF_EXPORT LogSilencer {
|
|
public:
|
|
LogSilencer();
|
|
~LogSilencer();
|
|
};
|
|
|
|
// ===================================================================
|
|
// emulates google3/base/callback.h
|
|
|
|
// Abstract interface for a callback. When calling an RPC, you must provide
|
|
// a Closure to call when the procedure completes. See the Service interface
|
|
// in service.h.
|
|
//
|
|
// To automatically construct a Closure which calls a particular function or
|
|
// method with a particular set of parameters, use the NewCallback() function.
|
|
// Example:
|
|
// void FooDone(const FooResponse* response) {
|
|
// ...
|
|
// }
|
|
//
|
|
// void CallFoo() {
|
|
// ...
|
|
// // When done, call FooDone() and pass it a pointer to the response.
|
|
// Closure* callback = NewCallback(&FooDone, response);
|
|
// // Make the call.
|
|
// service->Foo(controller, request, response, callback);
|
|
// }
|
|
//
|
|
// Example that calls a method:
|
|
// class Handler {
|
|
// public:
|
|
// ...
|
|
//
|
|
// void FooDone(const FooResponse* response) {
|
|
// ...
|
|
// }
|
|
//
|
|
// void CallFoo() {
|
|
// ...
|
|
// // When done, call FooDone() and pass it a pointer to the response.
|
|
// Closure* callback = NewCallback(this, &Handler::FooDone, response);
|
|
// // Make the call.
|
|
// service->Foo(controller, request, response, callback);
|
|
// }
|
|
// };
|
|
//
|
|
// Currently NewCallback() supports binding zero, one, or two arguments.
|
|
//
|
|
// Callbacks created with NewCallback() automatically delete themselves when
|
|
// executed. They should be used when a callback is to be called exactly
|
|
// once (usually the case with RPC callbacks). If a callback may be called
|
|
// a different number of times (including zero), create it with
|
|
// NewPermanentCallback() instead. You are then responsible for deleting the
|
|
// callback (using the "delete" keyword as normal).
|
|
//
|
|
// Note that NewCallback() is a bit touchy regarding argument types. Generally,
|
|
// the values you provide for the parameter bindings must exactly match the
|
|
// types accepted by the callback function. For example:
|
|
// void Foo(string s);
|
|
// NewCallback(&Foo, "foo"); // WON'T WORK: const char* != string
|
|
// NewCallback(&Foo, string("foo")); // WORKS
|
|
// Also note that the arguments cannot be references:
|
|
// void Foo(const string& s);
|
|
// string my_str;
|
|
// NewCallback(&Foo, my_str); // WON'T WORK: Can't use referecnes.
|
|
// However, correctly-typed pointers will work just fine.
|
|
class LIBPROTOBUF_EXPORT Closure {
|
|
public:
|
|
Closure() {}
|
|
virtual ~Closure();
|
|
|
|
virtual void Run() = 0;
|
|
|
|
private:
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Closure);
|
|
};
|
|
|
|
namespace internal {
|
|
|
|
class LIBPROTOBUF_EXPORT FunctionClosure0 : public Closure {
|
|
public:
|
|
typedef void (*FunctionType)();
|
|
|
|
FunctionClosure0(FunctionType function, bool self_deleting)
|
|
: function_(function), self_deleting_(self_deleting) {}
|
|
~FunctionClosure0();
|
|
|
|
void Run() {
|
|
bool needs_delete = self_deleting_; // read in case callback deletes
|
|
function_();
|
|
if (needs_delete) delete this;
|
|
}
|
|
|
|
private:
|
|
FunctionType function_;
|
|
bool self_deleting_;
|
|
};
|
|
|
|
template <typename Class>
|
|
class MethodClosure0 : public Closure {
|
|
public:
|
|
typedef void (Class::*MethodType)();
|
|
|
|
MethodClosure0(Class* object, MethodType method, bool self_deleting)
|
|
: object_(object), method_(method), self_deleting_(self_deleting) {}
|
|
~MethodClosure0() {}
|
|
|
|
void Run() {
|
|
bool needs_delete = self_deleting_; // read in case callback deletes
|
|
(object_->*method_)();
|
|
if (needs_delete) delete this;
|
|
}
|
|
|
|
private:
|
|
Class* object_;
|
|
MethodType method_;
|
|
bool self_deleting_;
|
|
};
|
|
|
|
template <typename Arg1>
|
|
class FunctionClosure1 : public Closure {
|
|
public:
|
|
typedef void (*FunctionType)(Arg1 arg1);
|
|
|
|
FunctionClosure1(FunctionType function, bool self_deleting,
|
|
Arg1 arg1)
|
|
: function_(function), self_deleting_(self_deleting),
|
|
arg1_(arg1) {}
|
|
~FunctionClosure1() {}
|
|
|
|
void Run() {
|
|
bool needs_delete = self_deleting_; // read in case callback deletes
|
|
function_(arg1_);
|
|
if (needs_delete) delete this;
|
|
}
|
|
|
|
private:
|
|
FunctionType function_;
|
|
bool self_deleting_;
|
|
Arg1 arg1_;
|
|
};
|
|
|
|
template <typename Class, typename Arg1>
|
|
class MethodClosure1 : public Closure {
|
|
public:
|
|
typedef void (Class::*MethodType)(Arg1 arg1);
|
|
|
|
MethodClosure1(Class* object, MethodType method, bool self_deleting,
|
|
Arg1 arg1)
|
|
: object_(object), method_(method), self_deleting_(self_deleting),
|
|
arg1_(arg1) {}
|
|
~MethodClosure1() {}
|
|
|
|
void Run() {
|
|
bool needs_delete = self_deleting_; // read in case callback deletes
|
|
(object_->*method_)(arg1_);
|
|
if (needs_delete) delete this;
|
|
}
|
|
|
|
private:
|
|
Class* object_;
|
|
MethodType method_;
|
|
bool self_deleting_;
|
|
Arg1 arg1_;
|
|
};
|
|
|
|
template <typename Arg1, typename Arg2>
|
|
class FunctionClosure2 : public Closure {
|
|
public:
|
|
typedef void (*FunctionType)(Arg1 arg1, Arg2 arg2);
|
|
|
|
FunctionClosure2(FunctionType function, bool self_deleting,
|
|
Arg1 arg1, Arg2 arg2)
|
|
: function_(function), self_deleting_(self_deleting),
|
|
arg1_(arg1), arg2_(arg2) {}
|
|
~FunctionClosure2() {}
|
|
|
|
void Run() {
|
|
bool needs_delete = self_deleting_; // read in case callback deletes
|
|
function_(arg1_, arg2_);
|
|
if (needs_delete) delete this;
|
|
}
|
|
|
|
private:
|
|
FunctionType function_;
|
|
bool self_deleting_;
|
|
Arg1 arg1_;
|
|
Arg2 arg2_;
|
|
};
|
|
|
|
template <typename Class, typename Arg1, typename Arg2>
|
|
class MethodClosure2 : public Closure {
|
|
public:
|
|
typedef void (Class::*MethodType)(Arg1 arg1, Arg2 arg2);
|
|
|
|
MethodClosure2(Class* object, MethodType method, bool self_deleting,
|
|
Arg1 arg1, Arg2 arg2)
|
|
: object_(object), method_(method), self_deleting_(self_deleting),
|
|
arg1_(arg1), arg2_(arg2) {}
|
|
~MethodClosure2() {}
|
|
|
|
void Run() {
|
|
bool needs_delete = self_deleting_; // read in case callback deletes
|
|
(object_->*method_)(arg1_, arg2_);
|
|
if (needs_delete) delete this;
|
|
}
|
|
|
|
private:
|
|
Class* object_;
|
|
MethodType method_;
|
|
bool self_deleting_;
|
|
Arg1 arg1_;
|
|
Arg2 arg2_;
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
// See Closure.
|
|
inline Closure* NewCallback(void (*function)()) {
|
|
return new internal::FunctionClosure0(function, true);
|
|
}
|
|
|
|
// See Closure.
|
|
inline Closure* NewPermanentCallback(void (*function)()) {
|
|
return new internal::FunctionClosure0(function, false);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Class>
|
|
inline Closure* NewCallback(Class* object, void (Class::*method)()) {
|
|
return new internal::MethodClosure0<Class>(object, method, true);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Class>
|
|
inline Closure* NewPermanentCallback(Class* object, void (Class::*method)()) {
|
|
return new internal::MethodClosure0<Class>(object, method, false);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Arg1>
|
|
inline Closure* NewCallback(void (*function)(Arg1),
|
|
Arg1 arg1) {
|
|
return new internal::FunctionClosure1<Arg1>(function, true, arg1);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Arg1>
|
|
inline Closure* NewPermanentCallback(void (*function)(Arg1),
|
|
Arg1 arg1) {
|
|
return new internal::FunctionClosure1<Arg1>(function, false, arg1);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Class, typename Arg1>
|
|
inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1),
|
|
Arg1 arg1) {
|
|
return new internal::MethodClosure1<Class, Arg1>(object, method, true, arg1);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Class, typename Arg1>
|
|
inline Closure* NewPermanentCallback(Class* object, void (Class::*method)(Arg1),
|
|
Arg1 arg1) {
|
|
return new internal::MethodClosure1<Class, Arg1>(object, method, false, arg1);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Arg1, typename Arg2>
|
|
inline Closure* NewCallback(void (*function)(Arg1, Arg2),
|
|
Arg1 arg1, Arg2 arg2) {
|
|
return new internal::FunctionClosure2<Arg1, Arg2>(
|
|
function, true, arg1, arg2);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Arg1, typename Arg2>
|
|
inline Closure* NewPermanentCallback(void (*function)(Arg1, Arg2),
|
|
Arg1 arg1, Arg2 arg2) {
|
|
return new internal::FunctionClosure2<Arg1, Arg2>(
|
|
function, false, arg1, arg2);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Class, typename Arg1, typename Arg2>
|
|
inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1, Arg2),
|
|
Arg1 arg1, Arg2 arg2) {
|
|
return new internal::MethodClosure2<Class, Arg1, Arg2>(
|
|
object, method, true, arg1, arg2);
|
|
}
|
|
|
|
// See Closure.
|
|
template <typename Class, typename Arg1, typename Arg2>
|
|
inline Closure* NewPermanentCallback(
|
|
Class* object, void (Class::*method)(Arg1, Arg2),
|
|
Arg1 arg1, Arg2 arg2) {
|
|
return new internal::MethodClosure2<Class, Arg1, Arg2>(
|
|
object, method, false, arg1, arg2);
|
|
}
|
|
|
|
// A function which does nothing. Useful for creating no-op callbacks, e.g.:
|
|
// Closure* nothing = NewCallback(&DoNothing);
|
|
void LIBPROTOBUF_EXPORT DoNothing();
|
|
|
|
// ===================================================================
|
|
// emulates google3/base/mutex.h
|
|
|
|
namespace internal {
|
|
|
|
// A Mutex is a non-reentrant (aka non-recursive) mutex. At most one thread T
|
|
// may hold a mutex at a given time. If T attempts to Lock() the same Mutex
|
|
// while holding it, T will deadlock.
|
|
class LIBPROTOBUF_EXPORT Mutex {
|
|
public:
|
|
// Create a Mutex that is not held by anybody.
|
|
Mutex();
|
|
|
|
// Destructor
|
|
~Mutex();
|
|
|
|
// Block if necessary until this Mutex is free, then acquire it exclusively.
|
|
void Lock();
|
|
|
|
// Release this Mutex. Caller must hold it exclusively.
|
|
void Unlock();
|
|
|
|
// Crash if this Mutex is not held exclusively by this thread.
|
|
// May fail to crash when it should; will never crash when it should not.
|
|
void AssertHeld();
|
|
|
|
private:
|
|
struct Internal;
|
|
Internal* mInternal;
|
|
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Mutex);
|
|
};
|
|
|
|
// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
|
|
class LIBPROTOBUF_EXPORT MutexLock {
|
|
public:
|
|
explicit MutexLock(Mutex *mu) : mu_(mu) { this->mu_->Lock(); }
|
|
~MutexLock() { this->mu_->Unlock(); }
|
|
private:
|
|
Mutex *const mu_;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLock);
|
|
};
|
|
|
|
// TODO(kenton): Implement these? Hard to implement portably.
|
|
typedef MutexLock ReaderMutexLock;
|
|
typedef MutexLock WriterMutexLock;
|
|
|
|
// MutexLockMaybe is like MutexLock, but is a no-op when mu is NULL.
|
|
class LIBPROTOBUF_EXPORT MutexLockMaybe {
|
|
public:
|
|
explicit MutexLockMaybe(Mutex *mu) :
|
|
mu_(mu) { if (this->mu_ != NULL) { this->mu_->Lock(); } }
|
|
~MutexLockMaybe() { if (this->mu_ != NULL) { this->mu_->Unlock(); } }
|
|
private:
|
|
Mutex *const mu_;
|
|
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLockMaybe);
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
// We made these internal so that they would show up as such in the docs,
|
|
// but we don't want to stick "internal::" in front of them everywhere.
|
|
using internal::Mutex;
|
|
using internal::MutexLock;
|
|
using internal::ReaderMutexLock;
|
|
using internal::WriterMutexLock;
|
|
using internal::MutexLockMaybe;
|
|
|
|
// ===================================================================
|
|
// from google3/base/type_traits.h
|
|
|
|
namespace internal {
|
|
|
|
// Specified by TR1 [4.7.4] Pointer modifications.
|
|
template<typename T> struct remove_pointer { typedef T type; };
|
|
template<typename T> struct remove_pointer<T*> { typedef T type; };
|
|
template<typename T> struct remove_pointer<T* const> { typedef T type; };
|
|
template<typename T> struct remove_pointer<T* volatile> { typedef T type; };
|
|
template<typename T> struct remove_pointer<T* const volatile> {
|
|
typedef T type; };
|
|
|
|
// ===================================================================
|
|
|
|
// Checks if the buffer contains structurally-valid UTF-8. Implemented in
|
|
// structurally_valid.cc.
|
|
LIBPROTOBUF_EXPORT bool IsStructurallyValidUTF8(const char* buf, int len);
|
|
|
|
} // namespace internal
|
|
|
|
// ===================================================================
|
|
// 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.
|
|
LIBPROTOBUF_EXPORT void ShutdownProtobufLibrary();
|
|
|
|
namespace internal {
|
|
|
|
// Register a function to be called when ShutdownProtocolBuffers() is called.
|
|
LIBPROTOBUF_EXPORT void OnShutdown(void (*func)());
|
|
|
|
} // namespace internal
|
|
|
|
#ifdef PROTOBUF_USE_EXCEPTIONS
|
|
class FatalException : public std::exception {
|
|
public:
|
|
FatalException(const char* filename, int line, const std::string& message)
|
|
: filename_(filename), line_(line), message_(message) {}
|
|
virtual ~FatalException() throw();
|
|
|
|
virtual const char* what() const throw();
|
|
|
|
const char* filename() const { return filename_; }
|
|
int line() const { return line_; }
|
|
const std::string& message() const { return message_; }
|
|
|
|
private:
|
|
const char* filename_;
|
|
const int line_;
|
|
const std::string message_;
|
|
};
|
|
#endif
|
|
|
|
// This is at the end of the file instead of the beginning to work around a bug
|
|
// in some versions of MSVC.
|
|
using namespace std; // Don't do this at home, kids.
|
|
|
|
} // namespace protobuf
|
|
} // namespace google
|
|
|
|
#endif // GOOGLE_PROTOBUF_COMMON_H__
|