Jisi Liu
9 years ago
commit
798ed10e7a
10 changed files with 1640 additions and 1404 deletions
@ -0,0 +1,463 @@ |
||||
#ifndef GOOGLE_PROTOBUF_STUBS_CALLBACK_H_ |
||||
#define GOOGLE_PROTOBUF_STUBS_CALLBACK_H_ |
||||
|
||||
#include <google/protobuf/stubs/macros.h> |
||||
#include <google/protobuf/stubs/type_traits.h> |
||||
|
||||
// ===================================================================
|
||||
// emulates google3/base/callback.h
|
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
|
||||
// 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); |
||||
}; |
||||
|
||||
template<typename R, typename A1> |
||||
class LIBPROTOBUF_EXPORT ResultCallback1 { |
||||
public: |
||||
ResultCallback1() {} |
||||
virtual ~ResultCallback1() {} |
||||
|
||||
virtual R Run(A1) = 0; |
||||
|
||||
private: |
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback1); |
||||
}; |
||||
|
||||
template<typename R, typename A1, typename A2> |
||||
class LIBPROTOBUF_EXPORT ResultCallback2 { |
||||
public: |
||||
ResultCallback2() {} |
||||
virtual ~ResultCallback2() {} |
||||
|
||||
virtual R Run(A1,A2) = 0; |
||||
|
||||
private: |
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback2); |
||||
}; |
||||
|
||||
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_; |
||||
}; |
||||
|
||||
template<typename R, typename Arg1> |
||||
class FunctionResultCallback_0_1 : public ResultCallback1<R, Arg1> { |
||||
public: |
||||
typedef R (*FunctionType)(Arg1 arg1); |
||||
|
||||
FunctionResultCallback_0_1(FunctionType function, bool self_deleting) |
||||
: function_(function), self_deleting_(self_deleting) {} |
||||
~FunctionResultCallback_0_1() {} |
||||
|
||||
R Run(Arg1 a1) { |
||||
bool needs_delete = self_deleting_; // read in case callback deletes
|
||||
R result = function_(a1); |
||||
if (needs_delete) delete this; |
||||
return result; |
||||
} |
||||
|
||||
private: |
||||
FunctionType function_; |
||||
bool self_deleting_; |
||||
}; |
||||
|
||||
template<typename R, typename P1, typename A1> |
||||
class FunctionResultCallback_1_1 : public ResultCallback1<R, A1> { |
||||
public: |
||||
typedef R (*FunctionType)(P1, A1); |
||||
|
||||
FunctionResultCallback_1_1(FunctionType function, bool self_deleting, |
||||
P1 p1) |
||||
: function_(function), self_deleting_(self_deleting), p1_(p1) {} |
||||
~FunctionResultCallback_1_1() {} |
||||
|
||||
R Run(A1 a1) { |
||||
bool needs_delete = self_deleting_; // read in case callback deletes
|
||||
R result = function_(p1_, a1); |
||||
if (needs_delete) delete this; |
||||
return result; |
||||
} |
||||
|
||||
private: |
||||
FunctionType function_; |
||||
bool self_deleting_; |
||||
P1 p1_; |
||||
}; |
||||
|
||||
template <typename T> |
||||
struct InternalConstRef { |
||||
typedef typename remove_reference<T>::type base_type; |
||||
typedef const base_type& type; |
||||
}; |
||||
|
||||
template <typename R, typename T, typename P1, typename P2, typename P3, |
||||
typename P4, typename P5, typename A1, typename A2> |
||||
class MethodResultCallback_5_2 : public ResultCallback2<R, A1, A2> { |
||||
public: |
||||
typedef R (T::*MethodType)(P1, P2, P3, P4, P5, A1, A2); |
||||
MethodResultCallback_5_2(T* object, MethodType method, bool self_deleting, |
||||
P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) |
||||
: object_(object), |
||||
method_(method), |
||||
self_deleting_(self_deleting), |
||||
p1_(p1), |
||||
p2_(p2), |
||||
p3_(p3), |
||||
p4_(p4), |
||||
p5_(p5) {} |
||||
~MethodResultCallback_5_2() {} |
||||
|
||||
R Run(A1 a1, A2 a2) { |
||||
bool needs_delete = self_deleting_; |
||||
R result = (object_->*method_)(p1_, p2_, p3_, p4_, p5_, a1, a2); |
||||
if (needs_delete) delete this; |
||||
return result; |
||||
} |
||||
|
||||
private: |
||||
T* object_; |
||||
MethodType method_; |
||||
bool self_deleting_; |
||||
typename remove_reference<P1>::type p1_; |
||||
typename remove_reference<P2>::type p2_; |
||||
typename remove_reference<P3>::type p3_; |
||||
typename remove_reference<P4>::type p4_; |
||||
typename remove_reference<P5>::type p5_; |
||||
}; |
||||
|
||||
} // 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); |
||||
} |
||||
|
||||
// See ResultCallback1
|
||||
template<typename R, typename A1> |
||||
inline ResultCallback1<R, A1>* NewCallback(R (*function)(A1)) { |
||||
return new internal::FunctionResultCallback_0_1<R, A1>(function, true); |
||||
} |
||||
|
||||
// See ResultCallback1
|
||||
template<typename R, typename A1> |
||||
inline ResultCallback1<R, A1>* NewPermanentCallback(R (*function)(A1)) { |
||||
return new internal::FunctionResultCallback_0_1<R, A1>(function, false); |
||||
} |
||||
|
||||
// See ResultCallback1
|
||||
template<typename R, typename P1, typename A1> |
||||
inline ResultCallback1<R, A1>* NewCallback(R (*function)(P1, A1), P1 p1) { |
||||
return new internal::FunctionResultCallback_1_1<R, P1, A1>( |
||||
function, true, p1); |
||||
} |
||||
|
||||
// See ResultCallback1
|
||||
template<typename R, typename P1, typename A1> |
||||
inline ResultCallback1<R, A1>* NewPermanentCallback( |
||||
R (*function)(P1, A1), P1 p1) { |
||||
return new internal::FunctionResultCallback_1_1<R, P1, A1>( |
||||
function, false, p1); |
||||
} |
||||
|
||||
// See MethodResultCallback_5_2
|
||||
template <typename R, typename T, typename P1, typename P2, typename P3, |
||||
typename P4, typename P5, typename A1, typename A2> |
||||
inline ResultCallback2<R, A1, A2>* NewPermanentCallback( |
||||
T* object, R (T::*function)(P1, P2, P3, P4, P5, A1, A2), |
||||
typename internal::InternalConstRef<P1>::type p1, |
||||
typename internal::InternalConstRef<P2>::type p2, |
||||
typename internal::InternalConstRef<P3>::type p3, |
||||
typename internal::InternalConstRef<P4>::type p4, |
||||
typename internal::InternalConstRef<P5>::type p5) { |
||||
return new internal::MethodResultCallback_5_2<R, T, P1, P2, P3, P4, P5, A1, |
||||
A2>(object, function, false, p1, |
||||
p2, p3, p4, p5); |
||||
} |
||||
|
||||
// A function which does nothing. Useful for creating no-op callbacks, e.g.:
|
||||
// Closure* nothing = NewCallback(&DoNothing);
|
||||
void LIBPROTOBUF_EXPORT DoNothing(); |
||||
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
|
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,235 @@ |
||||
// 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.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_LOGGING_H_ |
||||
#define GOOGLE_PROTOBUF_STUBS_LOGGING_H_ |
||||
|
||||
#include <google/protobuf/stubs/macros.h> |
||||
#include <google/protobuf/stubs/port.h> |
||||
|
||||
// ===================================================================
|
||||
// emulates google3/base/logging.h
|
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
|
||||
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 |
||||
}; |
||||
|
||||
class StringPiece; |
||||
namespace util { |
||||
class Status; |
||||
} |
||||
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<<(unsigned int value); |
||||
LogMessage& operator<<(long value); |
||||
LogMessage& operator<<(unsigned long value); |
||||
LogMessage& operator<<(long long value); |
||||
LogMessage& operator<<(unsigned long long value); |
||||
LogMessage& operator<<(double value); |
||||
LogMessage& operator<<(void* value); |
||||
LogMessage& operator<<(const StringPiece& value); |
||||
LogMessage& operator<<(const ::google::protobuf::util::Status& status); |
||||
|
||||
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); |
||||
}; |
||||
|
||||
template<typename T> |
||||
bool IsOk(T status) { return status.ok(); } |
||||
template<> |
||||
inline bool IsOk(bool status) { return status; } |
||||
|
||||
} // 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_OK |
||||
#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_CHECK_NOTNULL |
||||
|
||||
#undef GOOGLE_DLOG |
||||
#undef GOOGLE_DCHECK |
||||
#undef GOOGLE_DCHECK_OK |
||||
#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_OK(A) GOOGLE_CHECK(::google::protobuf::internal::IsOk(A)) |
||||
#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)) |
||||
|
||||
namespace internal { |
||||
template<typename T> |
||||
T* CheckNotNull(const char* /* file */, int /* line */, |
||||
const char* name, T* val) { |
||||
if (val == NULL) { |
||||
GOOGLE_LOG(FATAL) << name; |
||||
} |
||||
return val; |
||||
} |
||||
} // namespace internal
|
||||
#define GOOGLE_CHECK_NOTNULL(A) \ |
||||
::google::protobuf::internal::CheckNotNull(\
|
||||
__FILE__, __LINE__, "'" #A "' must not be NULL", (A)) |
||||
|
||||
#ifdef NDEBUG |
||||
|
||||
#define GOOGLE_DLOG GOOGLE_LOG_IF(INFO, false) |
||||
|
||||
#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION) |
||||
#define GOOGLE_DCHECK_OK(E) GOOGLE_DCHECK(::google::protobuf::internal::IsOk(E)) |
||||
#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_OK GOOGLE_CHECK_OK |
||||
#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(); |
||||
}; |
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_LOGGING_H_
|
||||
@ -0,0 +1,166 @@ |
||||
// 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.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_MACROS_H__ |
||||
#define GOOGLE_PROTOBUF_MACROS_H__ |
||||
|
||||
#include <google/protobuf/stubs/port.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
|
||||
#undef GOOGLE_DISALLOW_EVIL_CONSTRUCTORS |
||||
#define GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeName) \ |
||||
TypeName(const TypeName&); \
|
||||
void operator=(const TypeName&) |
||||
|
||||
#undef GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS |
||||
#define GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ |
||||
TypeName(); \
|
||||
TypeName(const TypeName&); \
|
||||
void operator=(const TypeName&) |
||||
|
||||
// ===================================================================
|
||||
// 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))))) |
||||
|
||||
// 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) \ |
||||
::google::protobuf::internal::CompileAssert<(bool(expr))> \
|
||||
msg[bool(expr) ? 1 : -1]; \
|
||||
(void)msg |
||||
|
||||
|
||||
// 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.
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_MACROS_H__
|
||||
@ -0,0 +1,144 @@ |
||||
// Copyright (c) 2006, Google Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// 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.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_MUTEX_H_ |
||||
#define GOOGLE_PROTOBUF_STUBS_MUTEX_H_ |
||||
|
||||
#include <google/protobuf/stubs/macros.h> |
||||
|
||||
// ===================================================================
|
||||
// emulates google3/base/mutex.h
|
||||
namespace google { |
||||
namespace protobuf { |
||||
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); |
||||
}; |
||||
|
||||
// Undefine the macros to workaround the conflicts with Google internal
|
||||
// MutexLock implementation.
|
||||
// TODO(liujisi): Remove the undef once internal macros are removed.
|
||||
#undef MutexLock |
||||
#undef ReaderMutexLock |
||||
#undef WriterMutexLock |
||||
#undef MutexLockMaybe |
||||
|
||||
// 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); |
||||
}; |
||||
|
||||
#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL) |
||||
template<typename T> |
||||
class ThreadLocalStorage { |
||||
public: |
||||
ThreadLocalStorage() { |
||||
pthread_key_create(&key_, &ThreadLocalStorage::Delete); |
||||
} |
||||
~ThreadLocalStorage() { |
||||
pthread_key_delete(key_); |
||||
} |
||||
T* Get() { |
||||
T* result = static_cast<T*>(pthread_getspecific(key_)); |
||||
if (result == NULL) { |
||||
result = new T(); |
||||
pthread_setspecific(key_, result); |
||||
} |
||||
return result; |
||||
} |
||||
private: |
||||
static void Delete(void* value) { |
||||
delete static_cast<T*>(value); |
||||
} |
||||
pthread_key_t key_; |
||||
|
||||
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadLocalStorage); |
||||
}; |
||||
#endif |
||||
|
||||
} // 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; |
||||
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_MUTEX_H_
|
||||
@ -0,0 +1,371 @@ |
||||
// 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.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_PORT_H_ |
||||
#define GOOGLE_PROTOBUF_STUBS_PORT_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 |
||||
|
||||
#undef PROTOBUF_LITTLE_ENDIAN |
||||
#ifdef _MSC_VER |
||||
// Assuming windows is always little-endian.
|
||||
#if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST) |
||||
#define PROTOBUF_LITTLE_ENDIAN 1 |
||||
#endif |
||||
#if _MSC_VER >= 1300 |
||||
// If MSVC has "/RTCc" set, it will complain about truncating casts at
|
||||
// runtime. This file contains some intentional truncating casts.
|
||||
#pragma runtime_checks("c", off) |
||||
#endif |
||||
#else |
||||
#include <sys/param.h> // __BYTE_ORDER |
||||
#if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \ |
||||
(defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN)) && \
|
||||
!defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST) |
||||
#define PROTOBUF_LITTLE_ENDIAN 1 |
||||
#endif |
||||
#endif |
||||
#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 |
||||
#else |
||||
#define LIBPROTOBUF_EXPORT |
||||
#define LIBPROTOC_EXPORT |
||||
#endif |
||||
|
||||
// ===================================================================
|
||||
// from google3/base/port.h
|
||||
namespace google { |
||||
namespace protobuf { |
||||
|
||||
typedef unsigned int uint; |
||||
|
||||
#ifdef _MSC_VER |
||||
typedef signed __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 signed char int8; |
||||
typedef short int16; |
||||
typedef int int32; |
||||
// NOTE: This should be "long long" for consistency with upstream, but
|
||||
// something is stacked against this particular type for 64bit hashing.
|
||||
// Switching it causes an obvious missing hash function (with an unobvious
|
||||
// cause) when building the tests.
|
||||
typedef int64_t int64; |
||||
|
||||
typedef unsigned char uint8; |
||||
typedef unsigned short uint16; |
||||
typedef unsigned int uint32; |
||||
// NOTE: This should be "unsigned long long" for consistency with upstream, but
|
||||
// something is stacked against this particular type for 64bit hashing.
|
||||
// Switching it causes an obvious missing hash function (with an unobvious
|
||||
// cause) when building the tests.
|
||||
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_NOINLINE |
||||
#if defined(__GNUC__) && (__GNUC__ > 3 ||(__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) |
||||
// For functions we want to force not inline.
|
||||
// Introduced in gcc 3.1.
|
||||
#define GOOGLE_ATTRIBUTE_NOINLINE __attribute__ ((noinline)) |
||||
#else |
||||
// Other compilers will have to figure it out for themselves.
|
||||
#define GOOGLE_ATTRIBUTE_NOINLINE |
||||
#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 |
||||
|
||||
#ifndef GOOGLE_PREDICT_FALSE |
||||
#ifdef __GNUC__ |
||||
// Provided at least since GCC 3.0.
|
||||
#define GOOGLE_PREDICT_FALSE(x) (__builtin_expect(x, 0)) |
||||
#else |
||||
#define GOOGLE_PREDICT_FALSE |
||||
#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 |
||||
|
||||
#define GOOGLE_GUARDED_BY(x) |
||||
#define GOOGLE_FALLTHROUGH_INTENDED |
||||
#define GOOGLE_ATTRIBUTE_COLD |
||||
|
||||
// x86 and x86-64 can perform unaligned loads/stores directly.
|
||||
#if defined(_M_X64) || defined(__x86_64__) || \ |
||||
defined(_M_IX86) || defined(__i386__) |
||||
|
||||
#define GOOGLE_UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16 *>(_p)) |
||||
#define GOOGLE_UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32 *>(_p)) |
||||
#define GOOGLE_UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64 *>(_p)) |
||||
|
||||
#define GOOGLE_UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16 *>(_p) = (_val)) |
||||
#define GOOGLE_UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32 *>(_p) = (_val)) |
||||
#define GOOGLE_UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64 *>(_p) = (_val)) |
||||
|
||||
#else |
||||
inline uint16 GOOGLE_UNALIGNED_LOAD16(const void *p) { |
||||
uint16 t; |
||||
memcpy(&t, p, sizeof t); |
||||
return t; |
||||
} |
||||
|
||||
inline uint32 GOOGLE_UNALIGNED_LOAD32(const void *p) { |
||||
uint32 t; |
||||
memcpy(&t, p, sizeof t); |
||||
return t; |
||||
} |
||||
|
||||
inline uint64 GOOGLE_UNALIGNED_LOAD64(const void *p) { |
||||
uint64 t; |
||||
memcpy(&t, p, sizeof t); |
||||
return t; |
||||
} |
||||
|
||||
inline void GOOGLE_UNALIGNED_STORE16(void *p, uint16 v) { |
||||
memcpy(p, &v, sizeof v); |
||||
} |
||||
|
||||
inline void GOOGLE_UNALIGNED_STORE32(void *p, uint32 v) { |
||||
memcpy(p, &v, sizeof v); |
||||
} |
||||
|
||||
inline void GOOGLE_UNALIGNED_STORE64(void *p, uint64 v) { |
||||
memcpy(p, &v, sizeof v); |
||||
} |
||||
#endif |
||||
|
||||
#if defined(_MSC_VER) |
||||
#define GOOGLE_THREAD_LOCAL __declspec(thread) |
||||
#else |
||||
#define GOOGLE_THREAD_LOCAL __thread |
||||
#endif |
||||
|
||||
// The following guarantees declaration of the byte swap functions, and
|
||||
// defines __BYTE_ORDER for MSVC
|
||||
#ifdef _MSC_VER |
||||
#include <stdlib.h> // NOLINT(build/include) |
||||
#define __BYTE_ORDER __LITTLE_ENDIAN |
||||
#define bswap_16(x) _byteswap_ushort(x) |
||||
#define bswap_32(x) _byteswap_ulong(x) |
||||
#define bswap_64(x) _byteswap_uint64(x) |
||||
|
||||
#elif defined(__APPLE__) |
||||
// Mac OS X / Darwin features
|
||||
#include <libkern/OSByteOrder.h> |
||||
#define bswap_16(x) OSSwapInt16(x) |
||||
#define bswap_32(x) OSSwapInt32(x) |
||||
#define bswap_64(x) OSSwapInt64(x) |
||||
|
||||
#elif defined(__GLIBC__) || defined(__CYGWIN__) |
||||
#include <byteswap.h> // IWYU pragma: export |
||||
|
||||
#else |
||||
|
||||
static inline uint16 bswap_16(uint16 x) { |
||||
return static_cast<uint16>(((x & 0xFF) << 8) | ((x & 0xFF00) >> 8)); |
||||
} |
||||
#define bswap_16(x) bswap_16(x) |
||||
static inline uint32 bswap_32(uint32 x) { |
||||
return (((x & 0xFF) << 24) | |
||||
((x & 0xFF00) << 8) | |
||||
((x & 0xFF0000) >> 8) | |
||||
((x & 0xFF000000) >> 24)); |
||||
} |
||||
#define bswap_32(x) bswap_32(x) |
||||
static inline uint64 bswap_64(uint64 x) { |
||||
return (((x & GOOGLE_ULONGLONG(0xFF)) << 56) | |
||||
((x & GOOGLE_ULONGLONG(0xFF00)) << 40) | |
||||
((x & GOOGLE_ULONGLONG(0xFF0000)) << 24) | |
||||
((x & GOOGLE_ULONGLONG(0xFF000000)) << 8) | |
||||
((x & GOOGLE_ULONGLONG(0xFF00000000)) >> 8) | |
||||
((x & GOOGLE_ULONGLONG(0xFF0000000000)) >> 24) | |
||||
((x & GOOGLE_ULONGLONG(0xFF000000000000)) >> 40) | |
||||
((x & GOOGLE_ULONGLONG(0xFF00000000000000)) >> 56)); |
||||
} |
||||
#define bswap_64(x) bswap_64(x) |
||||
|
||||
#endif |
||||
|
||||
// ===================================================================
|
||||
// from google3/util/endian/endian.h
|
||||
LIBPROTOBUF_EXPORT uint32 ghtonl(uint32 x); |
||||
|
||||
class BigEndian { |
||||
public: |
||||
#ifdef PROTOBUF_LITTLE_ENDIAN |
||||
|
||||
static uint16 FromHost16(uint16 x) { return bswap_16(x); } |
||||
static uint16 ToHost16(uint16 x) { return bswap_16(x); } |
||||
|
||||
static uint32 FromHost32(uint32 x) { return bswap_32(x); } |
||||
static uint32 ToHost32(uint32 x) { return bswap_32(x); } |
||||
|
||||
static uint64 FromHost64(uint64 x) { return bswap_64(x); } |
||||
static uint64 ToHost64(uint64 x) { return bswap_64(x); } |
||||
|
||||
static bool IsLittleEndian() { return true; } |
||||
|
||||
#else |
||||
|
||||
static uint16 FromHost16(uint16 x) { return x; } |
||||
static uint16 ToHost16(uint16 x) { return x; } |
||||
|
||||
static uint32 FromHost32(uint32 x) { return x; } |
||||
static uint32 ToHost32(uint32 x) { return x; } |
||||
|
||||
static uint64 FromHost64(uint64 x) { return x; } |
||||
static uint64 ToHost64(uint64 x) { return x; } |
||||
|
||||
static bool IsLittleEndian() { return false; } |
||||
|
||||
#endif /* ENDIAN */ |
||||
|
||||
// Functions to do unaligned loads and stores in big-endian order.
|
||||
static uint16 Load16(const void *p) { |
||||
return ToHost16(GOOGLE_UNALIGNED_LOAD16(p)); |
||||
} |
||||
|
||||
static void Store16(void *p, uint16 v) { |
||||
GOOGLE_UNALIGNED_STORE16(p, FromHost16(v)); |
||||
} |
||||
|
||||
static uint32 Load32(const void *p) { |
||||
return ToHost32(GOOGLE_UNALIGNED_LOAD32(p)); |
||||
} |
||||
|
||||
static void Store32(void *p, uint32 v) { |
||||
GOOGLE_UNALIGNED_STORE32(p, FromHost32(v)); |
||||
} |
||||
|
||||
static uint64 Load64(const void *p) { |
||||
return ToHost64(GOOGLE_UNALIGNED_LOAD64(p)); |
||||
} |
||||
|
||||
static void Store64(void *p, uint64 v) { |
||||
GOOGLE_UNALIGNED_STORE64(p, FromHost64(v)); |
||||
} |
||||
}; |
||||
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_PORT_H_
|
||||
@ -0,0 +1,236 @@ |
||||
// 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.
|
||||
|
||||
#ifndef GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_ |
||||
#define GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_ |
||||
|
||||
#include <google/protobuf/stubs/port.h> |
||||
|
||||
namespace google { |
||||
namespace protobuf { |
||||
|
||||
// ===================================================================
|
||||
// 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 initializing 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 initializing 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; |
||||
|
||||
|
||||
} // namespace protobuf
|
||||
} // namespace google
|
||||
|
||||
#endif // GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_
|
||||
Loading…
Reference in new issue