1fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Protocol Buffers - Google's data interchange format 2fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copyright 2008 Google Inc. All rights reserved. 3afb4b72037e3f13db208590fc782c4bc8e27f862Jeff Davidson// https://developers.google.com/protocol-buffers/ 4fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 5fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Redistribution and use in source and binary forms, with or without 6fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// modification, are permitted provided that the following conditions are 7fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// met: 8fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 9fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions of source code must retain the above copyright 10fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// notice, this list of conditions and the following disclaimer. 11fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions in binary form must reproduce the above 12fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// copyright notice, this list of conditions and the following disclaimer 13fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in the documentation and/or other materials provided with the 14fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// distribution. 15fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Neither the name of Google Inc. nor the names of its 16fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// contributors may be used to endorse or promote products derived from 17fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this software without specific prior written permission. 18fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 19fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 31fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Author: kenton@google.com (Kenton Varda) and others 32fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 33fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Contains basic types and utilities used by the rest of the library. 34fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 35fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifndef GOOGLE_PROTOBUF_COMMON_H__ 36fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_PROTOBUF_COMMON_H__ 37fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 38fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <assert.h> 39fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <stdlib.h> 40fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <cstddef> 41fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <string> 42fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <string.h> 43fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if defined(__osf__) 44fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tru64 lacks stdint.h, but has inttypes.h which defines a superset of 45fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// what stdint.h would define. 46fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <inttypes.h> 47fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#elif !defined(_MSC_VER) 48fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <stdint.h> 49fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 50fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 51a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#ifndef PROTOBUF_USE_EXCEPTIONS 52a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#if defined(_MSC_VER) && defined(_CPPUNWIND) 53a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson #define PROTOBUF_USE_EXCEPTIONS 1 54a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#elif defined(__EXCEPTIONS) 55a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson #define PROTOBUF_USE_EXCEPTIONS 1 56a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#else 57a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson #define PROTOBUF_USE_EXCEPTIONS 0 58a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#endif 59a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#endif 60a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 61a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#if PROTOBUF_USE_EXCEPTIONS 62a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#include <exception> 63a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#endif 64a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 65a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#if defined(_WIN32) && defined(GetMessage) 66a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson// Allow GetMessage to be used as a valid method name in protobuf classes. 67a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson// windows.h defines GetMessage() as a macro. Let's re-define it as an inline 68a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson// function. The inline function should be equivalent for C++ users. 69a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsoninline BOOL GetMessage_Win32( 70a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson LPMSG lpMsg, HWND hWnd, 71a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson UINT wMsgFilterMin, UINT wMsgFilterMax) { 72a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return GetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax); 73a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson} 74a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#undef GetMessage 75a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsoninline BOOL GetMessage( 76a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson LPMSG lpMsg, HWND hWnd, 77a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson UINT wMsgFilterMin, UINT wMsgFilterMax) { 78a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return GetMessage_Win32(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax); 79a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson} 80a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#endif 81a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 82a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 83fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace std {} 84fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 85fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace google { 86fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace protobuf { 87fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 88fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DISALLOW_EVIL_CONSTRUCTORS 89fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeName) \ 90fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TypeName(const TypeName&); \ 91fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void operator=(const TypeName&) 92fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 93fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if defined(_MSC_VER) && defined(PROTOBUF_USE_DLLS) 94fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #ifdef LIBPROTOBUF_EXPORTS 95fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #define LIBPROTOBUF_EXPORT __declspec(dllexport) 96fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #else 97fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #define LIBPROTOBUF_EXPORT __declspec(dllimport) 98fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #endif 99fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #ifdef LIBPROTOC_EXPORTS 100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #define LIBPROTOC_EXPORT __declspec(dllexport) 101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #else 102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #define LIBPROTOC_EXPORT __declspec(dllimport) 103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #endif 104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #define LIBPROTOBUF_EXPORT 106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville #define LIBPROTOC_EXPORT 107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Some of these constants are macros rather than const ints so that they can 112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// be used in #if directives. 113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The current version, represented as a single integer to make comparison 115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// easier: major * 10^6 + minor * 10^3 + micro 116afb4b72037e3f13db208590fc782c4bc8e27f862Jeff Davidson#define GOOGLE_PROTOBUF_VERSION 2006001 117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The minimum library version which works with the current version of the 119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// headers. 120a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 2006000 121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The minimum header version which works with the current version of 123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the library. This constant should only be used by protoc's C++ code 124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// generator. 125a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonstatic const int kMinHeaderVersionForLibrary = 2006000; 126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The minimum protoc version which works with the current version of the 128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// headers. 129a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#define GOOGLE_PROTOBUF_MIN_PROTOC_VERSION 2006000 130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The minimum header version which works with the current version of 132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// protoc. This constant should only be used in VerifyVersion(). 133a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonstatic const int kMinHeaderVersionForProtoc = 2006000; 134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Verifies that the headers and libraries are compatible. Use the macro 136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// below to call this. 137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid LIBPROTOBUF_EXPORT VerifyVersion(int headerVersion, int minLibraryVersion, 138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* filename); 139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Converts a numeric version number to a string. 141a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonstd::string LIBPROTOBUF_EXPORT VersionString(int version); 142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Place this macro in your main() function (or somewhere before you attempt 146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to use the protobuf library) to verify that the version you link against 147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// matches the headers you compiled against. If a version mismatch is 148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// detected, the process will abort. 149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_PROTOBUF_VERIFY_VERSION \ 150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::google::protobuf::internal::VerifyVersion( \ 151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION, \ 152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville __FILE__) 153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// =================================================================== 155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// from google3/base/port.h 156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef unsigned int uint; 158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef __int8 int8; 161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef __int16 int16; 162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef __int32 int32; 163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef __int64 int64; 164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef unsigned __int8 uint8; 166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef unsigned __int16 uint16; 167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef unsigned __int32 uint32; 168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef unsigned __int64 uint64; 169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef int8_t int8; 171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef int16_t int16; 172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef int32_t int32; 173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef int64_t int64; 174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef uint8_t uint8; 176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef uint16_t uint16; 177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef uint32_t uint32; 178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef uint64_t uint64; 179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// long long macros to be used because gcc and vc++ use different suffixes, 182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and different size specifiers in format strings 183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_LONGLONG 184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_ULONGLONG 185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_LL_FORMAT 186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef _MSC_VER 188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_LONGLONG(x) x##I64 189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_ULONGLONG(x) x##UI64 190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_LL_FORMAT "I64" // As in printf("%I64d", ...) 191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_LONGLONG(x) x##LL 193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_ULONGLONG(x) x##ULL 194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_LL_FORMAT "ll" // As in "%lld". Note that "q" is poor form also. 195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const int32 kint32max = 0x7FFFFFFF; 198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const int32 kint32min = -kint32max - 1; 199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const int64 kint64max = GOOGLE_LONGLONG(0x7FFFFFFFFFFFFFFF); 200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const int64 kint64min = -kint64max - 1; 201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const uint32 kuint32max = 0xFFFFFFFFu; 202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestatic const uint64 kuint64max = GOOGLE_ULONGLONG(0xFFFFFFFFFFFFFFFF); 203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 204d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// ------------------------------------------------------------------- 205d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Annotations: Some parts of the code have been annotated in ways that might 206d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// be useful to some compilers or tools, but are not supported universally. 207d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// You can #define these annotations yourself if the default implementation 208d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// is not right for you. 209d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 210d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifndef GOOGLE_ATTRIBUTE_ALWAYS_INLINE 211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if defined(__GNUC__) && (__GNUC__ > 3 ||(__GNUC__ == 3 && __GNUC_MINOR__ >= 1)) 212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// For functions we want to force inline. 213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Introduced in gcc 3.1. 214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline)) 215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Other compilers will have to figure it out for themselves. 217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_ATTRIBUTE_ALWAYS_INLINE 218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 219d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif 220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 221d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifndef GOOGLE_ATTRIBUTE_DEPRECATED 222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef __GNUC__ 223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// If the method/variable/type is used anywhere, produce a warning. 224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_ATTRIBUTE_DEPRECATED __attribute__((deprecated)) 225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_ATTRIBUTE_DEPRECATED 227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 228d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif 229d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 230d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifndef GOOGLE_PREDICT_TRUE 231d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifdef __GNUC__ 232d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Provided at least since GCC 3.0. 233d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#define GOOGLE_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1)) 234d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#else 235d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#define GOOGLE_PREDICT_TRUE 236d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif 237d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif 238d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville 239d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// Delimits a block of code which may write to memory which is simultaneously 240d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// written by other threads, but which has been determined to be thread-safe 241d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville// (e.g. because it is an idempotent write). 242d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifndef GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN 243d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#define GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN() 244d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif 245d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#ifndef GOOGLE_SAFE_CONCURRENT_WRITES_END 246d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#define GOOGLE_SAFE_CONCURRENT_WRITES_END() 247d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif 248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// =================================================================== 250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// from google3/base/basictypes.h 251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The GOOGLE_ARRAYSIZE(arr) macro returns the # of elements in an array arr. 253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The expression is a compile-time constant, and therefore can be 254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// used in defining new arrays, for example. 255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GOOGLE_ARRAYSIZE catches a few type errors. If you see a compiler error 257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "warning: division by zero in ..." 259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// when using GOOGLE_ARRAYSIZE, you are (wrongfully) giving it a pointer. 261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// You should only use GOOGLE_ARRAYSIZE on statically allocated arrays. 262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The following comments are on the implementation details, and can 264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// be ignored by the users. 265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in 267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the array) and sizeof(*(arr)) (the # of bytes in one array 268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// element). If the former is divisible by the latter, perhaps arr is 269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// indeed an array, in which case the division result is the # of 270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// elements in the array. Otherwise, arr cannot possibly be an array, 271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and we generate a compiler error to prevent the code from 272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// compiling. 273fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 274fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Since the size of bool is implementation-defined, we need to cast 275fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final 276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// result has type size_t. 277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This macro is not perfect as it wrongfully accepts certain 279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// pointers, namely where the pointer size is divisible by the pointee 280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// size. Since all our code has to go through a 32-bit compiler, 281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// where a pointer is 4 bytes, this means all pointers to a type whose 282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// size is 3 or greater than 4 will be (righteously) rejected. 283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Kudos to Jorg Brown for this simple and elegant implementation. 285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_ARRAYSIZE 287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_ARRAYSIZE(a) \ 288fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ((sizeof(a) / sizeof(*(a))) / \ 289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) 290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Use implicit_cast as a safe version of static_cast or const_cast 294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// for upcasting in the type hierarchy (i.e. casting a pointer to Foo 295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to a pointer to SuperclassOfFoo or casting a pointer to Foo to 296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// a const pointer to Foo). 297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// When you use implicit_cast, the compiler checks that the cast is safe. 298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Such explicit implicit_casts are necessary in surprisingly many 299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// situations where C++ demands an exact type match instead of an 300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// argument type convertable to a target type. 301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The From type can be inferred, so the preferred syntax for using 303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// implicit_cast is the same as for static_cast etc.: 304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// implicit_cast<ToType>(expr) 306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// implicit_cast would have been part of the C++ standard library, 308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// but the proposal was submitted too late. It will probably make 309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// its way into the language in the future. 310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate<typename To, typename From> 311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline To implicit_cast(From const &f) { 312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return f; 313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// When you upcast (that is, cast a pointer from type Foo to type 316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts 317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// always succeed. When you downcast (that is, cast a pointer from 318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because 319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// how do you know the pointer is really of type SubclassOfFoo? It 320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, 321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// when you downcast, you should use this macro. In debug mode, we 322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// use dynamic_cast<> to double-check the downcast is legal (we die 323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// if it's not). In normal mode, we do the efficient static_cast<> 324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// instead. Thus, it's important to test in debug mode to make sure 325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the cast is legal! 326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This is the only place in the code we should use dynamic_cast<>. 327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// In particular, you SHOULDN'T be using dynamic_cast<> in order to 328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// do RTTI (eg code like this: 329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); 330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); 331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// You should design the code some other way not to need this. 332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate<typename To, typename From> // use like this: down_cast<T*>(foo); 334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline To down_cast(From* f) { // so we only accept pointers 335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Ensures that To is a sub-type of From *. This test is here only 336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // for compile-time type checking, and has no overhead in an 337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // optimized build at run-time, as it will be optimized away 338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // completely. 339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (false) { 340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville implicit_cast<From*, To>(0); 341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 343d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#if !defined(NDEBUG) && !defined(GOOGLE_PROTOBUF_NO_RTTI) 344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville assert(f == NULL || dynamic_cast<To>(f) != NULL); // RTTI: debug mode only! 345d0332953cda33fb4f8e24ebff9c49159b69c43d6Wink Saville#endif 346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return static_cast<To>(f); 347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// We made these internal so that they would show up as such in the docs, 352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// but we don't want to stick "internal::" in front of them everywhere. 353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::implicit_cast; 354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::down_cast; 355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The COMPILE_ASSERT macro can be used to verify that a compile time 357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// expression is true. For example, you could use it to verify the 358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// size of a static array: 359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// COMPILE_ASSERT(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES, 361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// content_type_names_incorrect_size); 362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// or to make sure a struct is smaller than a certain size: 364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large); 366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The second argument to the macro is the name of the variable. If 368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the expression is false, most compilers will issue a warning/error 369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// containing the name of the variable. 370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <bool> 374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillestruct CompileAssert { 375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_COMPILE_ASSERT 380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_COMPILE_ASSERT(expr, msg) \ 381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef ::google::protobuf::internal::CompileAssert<(bool(expr))> \ 382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg[bool(expr) ? 1 : -1] 383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 384a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Implementation details of COMPILE_ASSERT: 386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// - COMPILE_ASSERT works by defining an array type that has -1 388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// elements (and thus is invalid) when the expression is false. 389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// - The simpler definition 391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1] 393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// does not work, as gcc supports variable-length arrays whose sizes 395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// are determined at run-time (this is gcc's extension and not part 396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of the C++ standard). As a result, gcc fails to reject the 397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// following code with the simple definition: 398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// int foo; 400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is 401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // not a compile-time constant. 402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// - By using the type CompileAssert<(bool(expr))>, we ensures that 404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// expr is a compile-time constant. (Template arguments must be 405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// determined at compile-time.) 406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// - The outter parentheses in CompileAssert<(bool(expr))> are necessary 408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written 409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// CompileAssert<bool(expr)> 411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// instead, these compilers will refuse to compile 413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// COMPILE_ASSERT(5 > 0, some_message); 415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (They seem to think the ">" in "5 > 0" marks the end of the 417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// template argument list.) 418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// - The array size is (bool(expr) ? 1 : -1), instead of simply 420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ((expr) ? 1 : -1). 422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This is to avoid running into a bug in MS VC 7.1, which 424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. 425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// =================================================================== 427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// from google3/base/scoped_ptr.h 428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This is an implementation designed to match the anticipated future TR2 432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// implementation of the scoped_ptr class, and its closely-related brethren, 433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// scoped_array, scoped_ptr_malloc, and make_scoped_ptr. 434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <class C> class scoped_ptr; 436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <class C> class scoped_array; 437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T> 439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// automatically deletes the pointer it holds (if any). 440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// That is, scoped_ptr<T> owns the T object that it points to. 441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object. 442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The size of a scoped_ptr is small: 444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// sizeof(scoped_ptr<C>) == sizeof(C*) 445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <class C> 446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass scoped_ptr { 447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The element type 450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef C element_type; 451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Constructor. Defaults to intializing with NULL. 453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // There is no way to create an uninitialized scoped_ptr. 454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The input parameter must be allocated with new. 455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit scoped_ptr(C* p = NULL) : ptr_(p) { } 456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Destructor. If there is a C object, delete it. 458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We don't need to test ptr_ == NULL because C++ does that for us. 459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~scoped_ptr() { 460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville enum { type_must_be_complete = sizeof(C) }; 461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete ptr_; 462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Reset. Deletes the current owned object, if any. 465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Then takes ownership of a new object, if given. 466fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // this->reset(this->get()) works. 467fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void reset(C* p = NULL) { 468fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (p != ptr_) { 469fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville enum { type_must_be_complete = sizeof(C) }; 470fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete ptr_; 471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ptr_ = p; 472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 475fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Accessors to get the owned object. 476fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // operator* and operator-> will assert() if there is no current object. 477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C& operator*() const { 478fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville assert(ptr_ != NULL); 479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return *ptr_; 480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* operator->() const { 482fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville assert(ptr_ != NULL); 483fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return ptr_; 484fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 485fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* get() const { return ptr_; } 486fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Comparison operators. 488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // These return whether two scoped_ptr refer to the same object, not just to 489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // two different but equal objects. 490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool operator==(C* p) const { return ptr_ == p; } 491fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool operator!=(C* p) const { return ptr_ != p; } 492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Swap two scoped pointers. 494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void swap(scoped_ptr& p2) { 495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* tmp = ptr_; 496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ptr_ = p2.ptr_; 497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville p2.ptr_ = tmp; 498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 499fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 500fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Release a pointer. 501fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The return value is the current pointer held by this object. 502fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If this object holds a NULL pointer, the return value is NULL. 503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // After this operation, this object will hold a NULL pointer, 504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // and will not own the object any more. 505fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* release() { 506fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* retVal = ptr_; 507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ptr_ = NULL; 508fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return retVal; 509fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 510fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 511fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* ptr_; 513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Forbid comparison of scoped_ptr types. If C2 != C, it totally doesn't 515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // make sense, and if C2 == C, it still doesn't make sense because you should 516fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // never have the same object owned by two different scoped_ptrs. 517fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <class C2> bool operator==(scoped_ptr<C2> const& p2) const; 518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const; 519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Disallow evil constructors 521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville scoped_ptr(const scoped_ptr&); 522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void operator=(const scoped_ptr&); 523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// scoped_array<C> is like scoped_ptr<C>, except that the caller must allocate 526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// with new [] and the destructor deletes objects with delete []. 527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// As with scoped_ptr<C>, a scoped_array<C> either points to an object 529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// or is NULL. A scoped_array<C> owns the object that it points to. 530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Size: sizeof(scoped_array<C>) == sizeof(C*) 532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <class C> 533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass scoped_array { 534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 536fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The element type 537fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef C element_type; 538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Constructor. Defaults to intializing with NULL. 540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // There is no way to create an uninitialized scoped_array. 541fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The input parameter must be allocated with new []. 542fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit scoped_array(C* p = NULL) : array_(p) { } 543fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 544fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Destructor. If there is a C object, delete it. 545fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // We don't need to test ptr_ == NULL because C++ does that for us. 546fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~scoped_array() { 547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville enum { type_must_be_complete = sizeof(C) }; 548fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete[] array_; 549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 551fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Reset. Deletes the current owned object, if any. 552fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Then takes ownership of a new object, if given. 553fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // this->reset(this->get()) works. 554fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void reset(C* p = NULL) { 555fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (p != array_) { 556fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville enum { type_must_be_complete = sizeof(C) }; 557fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville delete[] array_; 558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville array_ = p; 559fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 560fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 561fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Get one element of the current object. 563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Will assert() if there is no current object, or index i is negative. 564fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C& operator[](std::ptrdiff_t i) const { 565fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville assert(i >= 0); 566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville assert(array_ != NULL); 567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return array_[i]; 568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 569fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 570fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Get a pointer to the zeroth element of the current object. 571fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If there is no current object, return NULL. 572fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* get() const { 573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return array_; 574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 575fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 576fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Comparison operators. 577fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // These return whether two scoped_array refer to the same object, not just to 578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // two different but equal objects. 579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool operator==(C* p) const { return array_ == p; } 580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool operator!=(C* p) const { return array_ != p; } 581fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 582fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Swap two scoped arrays. 583fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void swap(scoped_array& p2) { 584fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* tmp = array_; 585fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville array_ = p2.array_; 586fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville p2.array_ = tmp; 587fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 588fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 589fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Release an array. 590fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // The return value is the current pointer held by this object. 591fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If this object holds a NULL pointer, the return value is NULL. 592fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // After this operation, this object will hold a NULL pointer, 593fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // and will not own the object any more. 594fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* release() { 595fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* retVal = array_; 596fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville array_ = NULL; 597fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return retVal; 598fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 599fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 600fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 601fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville C* array_; 602fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 603fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Forbid comparison of different scoped_array types. 604fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <class C2> bool operator==(scoped_array<C2> const& p2) const; 605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville template <class C2> bool operator!=(scoped_array<C2> const& p2) const; 606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Disallow evil constructors 608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville scoped_array(const scoped_array&); 609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void operator=(const scoped_array&); 610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 611fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 614fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// We made these internal so that they would show up as such in the docs, 615fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// but we don't want to stick "internal::" in front of them everywhere. 616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::scoped_ptr; 617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::scoped_array; 618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// =================================================================== 620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// emulates google3/base/logging.h 621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleenum LogLevel { 623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LOGLEVEL_INFO, // Informational. This is never actually used by 624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // libprotobuf. 625fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LOGLEVEL_WARNING, // Warns about issues that, although not technically a 626fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // problem now, could cause problems in the future. For 627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // example, a // warning will be printed when parsing a 628fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // message that is near the message size limit. 629fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LOGLEVEL_ERROR, // An error occurred which should never happen during 630fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // normal use. 631fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LOGLEVEL_FATAL, // An error occurred from which the library cannot 632fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // recover. This usually indicates a programming error 633fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // in the code which calls the library, especially when 634fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // compiled in debug mode. 635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 636fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef NDEBUG 637fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LOGLEVEL_DFATAL = LOGLEVEL_ERROR 638fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else 639fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LOGLEVEL_DFATAL = LOGLEVEL_FATAL 640fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 641fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 642fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 643fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 644fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 645fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LogFinisher; 646fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 647fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LIBPROTOBUF_EXPORT LogMessage { 648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogMessage(LogLevel level, const char* filename, int line); 650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~LogMessage(); 651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 652a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson LogMessage& operator<<(const std::string& value); 653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogMessage& operator<<(const char* value); 654fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogMessage& operator<<(char value); 655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogMessage& operator<<(int value); 656fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogMessage& operator<<(uint value); 657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogMessage& operator<<(long value); 658fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogMessage& operator<<(unsigned long value); 659fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogMessage& operator<<(double value); 660fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 661fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 662fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville friend class LogFinisher; 663fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Finish(); 664fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 665fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogLevel level_; 666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* filename_; 667fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int line_; 668a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson std::string message_; 669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Used to make the entire "LOG(BLAH) << etc." expression have a void return 672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// type and print a newline after each message. 673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LIBPROTOBUF_EXPORT LogFinisher { 674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void operator=(LogMessage& other); 676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 678fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 679fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 680fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Undef everything in case we're being mixed with some other Google library 681fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// which already defined them itself. Presumably all Google libraries will 682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// support the same syntax for these so it should not be a big deal if they 683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// end up using our definitions instead. 684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_LOG 685fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_LOG_IF 686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 687fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_CHECK 688a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#undef GOOGLE_CHECK_OK 689fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_CHECK_EQ 690fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_CHECK_NE 691fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_CHECK_LT 692fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_CHECK_LE 693fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_CHECK_GT 694fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_CHECK_GE 695a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#undef GOOGLE_CHECK_NOTNULL 696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DLOG 698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DCHECK 699fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DCHECK_EQ 700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DCHECK_NE 701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DCHECK_LT 702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DCHECK_LE 703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DCHECK_GT 704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GOOGLE_DCHECK_GE 705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_LOG(LEVEL) \ 707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::google::protobuf::internal::LogFinisher() = \ 708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::google::protobuf::internal::LogMessage( \ 709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__) 710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_LOG_IF(LEVEL, CONDITION) \ 711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL) 712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_CHECK(EXPRESSION) \ 714fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": " 715a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#define GOOGLE_CHECK_OK(A) GOOGLE_CHECK(A) 716fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_CHECK_EQ(A, B) GOOGLE_CHECK((A) == (B)) 717fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_CHECK_NE(A, B) GOOGLE_CHECK((A) != (B)) 718fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_CHECK_LT(A, B) GOOGLE_CHECK((A) < (B)) 719fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_CHECK_LE(A, B) GOOGLE_CHECK((A) <= (B)) 720fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_CHECK_GT(A, B) GOOGLE_CHECK((A) > (B)) 721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_CHECK_GE(A, B) GOOGLE_CHECK((A) >= (B)) 722fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 723a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonnamespace internal { 724a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsontemplate<typename T> 725a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff DavidsonT* CheckNotNull(const char* /* file */, int /* line */, 726a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson const char* name, T* val) { 727a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if (val == NULL) { 728a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson GOOGLE_LOG(FATAL) << name; 729a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson } 730a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson return val; 731a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson} 732a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson} // namespace internal 733a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#define GOOGLE_CHECK_NOTNULL(A) \ 734a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson internal::CheckNotNull(__FILE__, __LINE__, "'" #A "' must not be NULL", (A)) 735a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 736fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#ifdef NDEBUG 737fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 738fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DLOG GOOGLE_LOG_IF(INFO, false) 739fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 740fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION) 741fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_EQ(A, B) GOOGLE_DCHECK((A) == (B)) 742fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B)) 743fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) < (B)) 744fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_LE(A, B) GOOGLE_DCHECK((A) <= (B)) 745fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_GT(A, B) GOOGLE_DCHECK((A) > (B)) 746fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B)) 747fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 748fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#else // NDEBUG 749fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 750fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DLOG GOOGLE_LOG 751fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 752fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK GOOGLE_CHECK 753fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_EQ GOOGLE_CHECK_EQ 754fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_NE GOOGLE_CHECK_NE 755fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_LT GOOGLE_CHECK_LT 756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_LE GOOGLE_CHECK_LE 757fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_GT GOOGLE_CHECK_GT 758fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GOOGLE_DCHECK_GE GOOGLE_CHECK_GE 759fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 760fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // !NDEBUG 761fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 762fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef void LogHandler(LogLevel level, const char* filename, int line, 763a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson const std::string& message); 764fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 765fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The protobuf library sometimes writes warning and error messages to 766fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// stderr. These messages are primarily useful for developers, but may 767fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// also help end users figure out a problem. If you would prefer that 768fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// these messages be sent somewhere other than stderr, call SetLogHandler() 769fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to set your own handler. This returns the old handler. Set the handler 770fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// to NULL to ignore log messages (but see also LogSilencer, below). 771fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 772fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Obviously, SetLogHandler is not thread-safe. You should only call it 773fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// at initialization time, and probably not from library code. If you 774fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// simply want to suppress log messages temporarily (e.g. because you 775fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// have some code that tends to trigger them frequently and you know 776fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the warnings are not important to you), use the LogSilencer class 777fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// below. 778fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT LogHandler* SetLogHandler(LogHandler* new_func); 779fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 780fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Create a LogSilencer if you want to temporarily suppress all log 781fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// messages. As long as any LogSilencer objects exist, non-fatal 782fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// log messages will be discarded (the current LogHandler will *not* 783fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// be called). Constructing a LogSilencer is thread-safe. You may 784fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// accidentally suppress log messages occurring in another thread, but 785fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// since messages are generally for debugging purposes only, this isn't 786fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// a big deal. If you want to intercept log messages, use SetLogHandler(). 787fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LIBPROTOBUF_EXPORT LogSilencer { 788fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 789fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville LogSilencer(); 790fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~LogSilencer(); 791fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 792fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 793fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// =================================================================== 794fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// emulates google3/base/callback.h 795fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 796fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Abstract interface for a callback. When calling an RPC, you must provide 797fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// a Closure to call when the procedure completes. See the Service interface 798fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in service.h. 799fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 800fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// To automatically construct a Closure which calls a particular function or 801fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// method with a particular set of parameters, use the NewCallback() function. 802fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Example: 803fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void FooDone(const FooResponse* response) { 804fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ... 805fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 806fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 807fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void CallFoo() { 808fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ... 809fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // When done, call FooDone() and pass it a pointer to the response. 810fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Closure* callback = NewCallback(&FooDone, response); 811fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // Make the call. 812fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// service->Foo(controller, request, response, callback); 813fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 814fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 815fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Example that calls a method: 816fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// class Handler { 817fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// public: 818fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ... 819fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 820fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void FooDone(const FooResponse* response) { 821fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ... 822fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 823fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 824fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void CallFoo() { 825fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ... 826fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // When done, call FooDone() and pass it a pointer to the response. 827fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Closure* callback = NewCallback(this, &Handler::FooDone, response); 828fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// // Make the call. 829fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// service->Foo(controller, request, response, callback); 830fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// } 831fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// }; 832fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 833fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Currently NewCallback() supports binding zero, one, or two arguments. 834fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 835fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Callbacks created with NewCallback() automatically delete themselves when 836fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// executed. They should be used when a callback is to be called exactly 837fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// once (usually the case with RPC callbacks). If a callback may be called 838fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// a different number of times (including zero), create it with 839fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// NewPermanentCallback() instead. You are then responsible for deleting the 840fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// callback (using the "delete" keyword as normal). 841fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 842fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Note that NewCallback() is a bit touchy regarding argument types. Generally, 843fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the values you provide for the parameter bindings must exactly match the 844fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// types accepted by the callback function. For example: 845fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void Foo(string s); 846fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// NewCallback(&Foo, "foo"); // WON'T WORK: const char* != string 847fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// NewCallback(&Foo, string("foo")); // WORKS 848fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Also note that the arguments cannot be references: 849fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// void Foo(const string& s); 850fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// string my_str; 851fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// NewCallback(&Foo, my_str); // WON'T WORK: Can't use referecnes. 852fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// However, correctly-typed pointers will work just fine. 853fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LIBPROTOBUF_EXPORT Closure { 854fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 855fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Closure() {} 856fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual ~Closure(); 857fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 858fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void Run() = 0; 859fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 860fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 861fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Closure); 862fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 863fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 864fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 865fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 866fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LIBPROTOBUF_EXPORT FunctionClosure0 : public Closure { 867fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 868fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef void (*FunctionType)(); 869fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 870fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FunctionClosure0(FunctionType function, bool self_deleting) 871fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : function_(function), self_deleting_(self_deleting) {} 872fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~FunctionClosure0(); 873fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 874fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run() { 875a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bool needs_delete = self_deleting_; // read in case callback deletes 876fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville function_(); 877a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if (needs_delete) delete this; 878fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 879fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 880fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 881fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FunctionType function_; 882fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool self_deleting_; 883fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 884fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 885fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class> 886fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass MethodClosure0 : public Closure { 887fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 888fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef void (Class::*MethodType)(); 889fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 890fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MethodClosure0(Class* object, MethodType method, bool self_deleting) 891fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : object_(object), method_(method), self_deleting_(self_deleting) {} 892fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~MethodClosure0() {} 893fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 894fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run() { 895a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bool needs_delete = self_deleting_; // read in case callback deletes 896fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (object_->*method_)(); 897a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if (needs_delete) delete this; 898fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 899fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 900fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 901fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Class* object_; 902fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MethodType method_; 903fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool self_deleting_; 904fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 905fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 906fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Arg1> 907fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass FunctionClosure1 : public Closure { 908fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 909fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef void (*FunctionType)(Arg1 arg1); 910fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 911fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FunctionClosure1(FunctionType function, bool self_deleting, 912fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1) 913fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : function_(function), self_deleting_(self_deleting), 914fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville arg1_(arg1) {} 915fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~FunctionClosure1() {} 916fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 917fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run() { 918a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bool needs_delete = self_deleting_; // read in case callback deletes 919fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville function_(arg1_); 920a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if (needs_delete) delete this; 921fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 922fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 923fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 924fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FunctionType function_; 925fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool self_deleting_; 926fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1_; 927fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 928fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 929fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class, typename Arg1> 930fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass MethodClosure1 : public Closure { 931fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 932fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef void (Class::*MethodType)(Arg1 arg1); 933fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 934fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MethodClosure1(Class* object, MethodType method, bool self_deleting, 935fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1) 936fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : object_(object), method_(method), self_deleting_(self_deleting), 937fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville arg1_(arg1) {} 938fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~MethodClosure1() {} 939fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 940fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run() { 941a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bool needs_delete = self_deleting_; // read in case callback deletes 942fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (object_->*method_)(arg1_); 943a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if (needs_delete) delete this; 944fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 945fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 946fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 947fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Class* object_; 948fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MethodType method_; 949fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool self_deleting_; 950fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1_; 951fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 952fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 953fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Arg1, typename Arg2> 954fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass FunctionClosure2 : public Closure { 955fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 956fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef void (*FunctionType)(Arg1 arg1, Arg2 arg2); 957fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 958fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FunctionClosure2(FunctionType function, bool self_deleting, 959fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1, Arg2 arg2) 960fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : function_(function), self_deleting_(self_deleting), 961fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville arg1_(arg1), arg2_(arg2) {} 962fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~FunctionClosure2() {} 963fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 964fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run() { 965a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bool needs_delete = self_deleting_; // read in case callback deletes 966fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville function_(arg1_, arg2_); 967a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if (needs_delete) delete this; 968fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 969fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 970fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 971fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FunctionType function_; 972fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool self_deleting_; 973fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1_; 974fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg2 arg2_; 975fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 976fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 977fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class, typename Arg1, typename Arg2> 978fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass MethodClosure2 : public Closure { 979fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 980fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef void (Class::*MethodType)(Arg1 arg1, Arg2 arg2); 981fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 982fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MethodClosure2(Class* object, MethodType method, bool self_deleting, 983fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1, Arg2 arg2) 984fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville : object_(object), method_(method), self_deleting_(self_deleting), 985fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville arg1_(arg1), arg2_(arg2) {} 986fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~MethodClosure2() {} 987fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 988fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Run() { 989a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson bool needs_delete = self_deleting_; // read in case callback deletes 990fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville (object_->*method_)(arg1_, arg2_); 991a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson if (needs_delete) delete this; 992fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 993fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 994fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 995fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Class* object_; 996fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville MethodType method_; 997fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool self_deleting_; 998fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1_; 999fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg2 arg2_; 1000fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1001fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1002fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1003fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1004fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1005fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewCallback(void (*function)()) { 1006fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::FunctionClosure0(function, true); 1007fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1008fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1009fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1010fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewPermanentCallback(void (*function)()) { 1011fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::FunctionClosure0(function, false); 1012fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1013fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1014fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1015fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class> 1016fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewCallback(Class* object, void (Class::*method)()) { 1017fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::MethodClosure0<Class>(object, method, true); 1018fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1019fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1020fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1021fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class> 1022fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewPermanentCallback(Class* object, void (Class::*method)()) { 1023fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::MethodClosure0<Class>(object, method, false); 1024fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1025fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1026fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1027fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Arg1> 1028fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewCallback(void (*function)(Arg1), 1029fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1) { 1030fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::FunctionClosure1<Arg1>(function, true, arg1); 1031fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1032fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1033fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1034fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Arg1> 1035fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewPermanentCallback(void (*function)(Arg1), 1036fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1) { 1037fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::FunctionClosure1<Arg1>(function, false, arg1); 1038fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1039fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1040fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1041fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class, typename Arg1> 1042fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewCallback(Class* object, void (Class::*method)(Arg1), 1043fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1) { 1044fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::MethodClosure1<Class, Arg1>(object, method, true, arg1); 1045fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1046fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1047fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1048fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class, typename Arg1> 1049fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewPermanentCallback(Class* object, void (Class::*method)(Arg1), 1050fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1) { 1051fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::MethodClosure1<Class, Arg1>(object, method, false, arg1); 1052fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1053fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1054fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1055fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Arg1, typename Arg2> 1056fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewCallback(void (*function)(Arg1, Arg2), 1057fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1, Arg2 arg2) { 1058fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::FunctionClosure2<Arg1, Arg2>( 1059fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville function, true, arg1, arg2); 1060fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1061fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1062fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1063fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Arg1, typename Arg2> 1064fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewPermanentCallback(void (*function)(Arg1, Arg2), 1065fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1, Arg2 arg2) { 1066fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::FunctionClosure2<Arg1, Arg2>( 1067fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville function, false, arg1, arg2); 1068fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1069fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1070fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1071fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class, typename Arg1, typename Arg2> 1072fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewCallback(Class* object, void (Class::*method)(Arg1, Arg2), 1073fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1, Arg2 arg2) { 1074fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::MethodClosure2<Class, Arg1, Arg2>( 1075fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville object, method, true, arg1, arg2); 1076fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1077fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1078fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// See Closure. 1079fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename Class, typename Arg1, typename Arg2> 1080fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleinline Closure* NewPermanentCallback( 1081fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Class* object, void (Class::*method)(Arg1, Arg2), 1082fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Arg1 arg1, Arg2 arg2) { 1083fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return new internal::MethodClosure2<Class, Arg1, Arg2>( 1084fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville object, method, false, arg1, arg2); 1085fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 1086fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1087fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A function which does nothing. Useful for creating no-op callbacks, e.g.: 1088fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Closure* nothing = NewCallback(&DoNothing); 1089fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid LIBPROTOBUF_EXPORT DoNothing(); 1090fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1091fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// =================================================================== 1092fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// emulates google3/base/mutex.h 1093fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1094fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 1095fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1096fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A Mutex is a non-reentrant (aka non-recursive) mutex. At most one thread T 1097fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// may hold a mutex at a given time. If T attempts to Lock() the same Mutex 1098fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// while holding it, T will deadlock. 1099fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LIBPROTOBUF_EXPORT Mutex { 1100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Create a Mutex that is not held by anybody. 1102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Mutex(); 1103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Destructor 1105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~Mutex(); 1106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Block if necessary until this Mutex is free, then acquire it exclusively. 1108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Lock(); 1109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Release this Mutex. Caller must hold it exclusively. 1111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void Unlock(); 1112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Crash if this Mutex is not held exclusively by this thread. 1114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // May fail to crash when it should; will never crash when it should not. 1115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void AssertHeld(); 1116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 1118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville struct Internal; 1119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Internal* mInternal; 1120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Mutex); 1122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// MutexLock(mu) acquires mu when constructed and releases it when destroyed. 1125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LIBPROTOBUF_EXPORT MutexLock { 1126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit MutexLock(Mutex *mu) : mu_(mu) { this->mu_->Lock(); } 1128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~MutexLock() { this->mu_->Unlock(); } 1129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 1130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Mutex *const mu_; 1131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLock); 1132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// TODO(kenton): Implement these? Hard to implement portably. 1135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef MutexLock ReaderMutexLock; 1136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletypedef MutexLock WriterMutexLock; 1137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// MutexLockMaybe is like MutexLock, but is a no-op when mu is NULL. 1139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass LIBPROTOBUF_EXPORT MutexLockMaybe { 1140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 1141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit MutexLockMaybe(Mutex *mu) : 1142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville mu_(mu) { if (this->mu_ != NULL) { this->mu_->Lock(); } } 1143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ~MutexLockMaybe() { if (this->mu_ != NULL) { this->mu_->Unlock(); } } 1144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 1145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Mutex *const mu_; 1146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLockMaybe); 1147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 1148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// We made these internal so that they would show up as such in the docs, 1152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// but we don't want to stick "internal::" in front of them everywhere. 1153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::Mutex; 1154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::MutexLock; 1155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::ReaderMutexLock; 1156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::WriterMutexLock; 1157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing internal::MutexLockMaybe; 1158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// =================================================================== 1160a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson// from google3/util/utf8/public/unilib.h 1161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 1163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Checks if the buffer contains structurally-valid UTF-8. Implemented in 1165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// structurally_valid.cc. 1166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT bool IsStructurallyValidUTF8(const char* buf, int len); 1167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// =================================================================== 1171a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson// from google3/util/endian/endian.h 1172a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff DavidsonLIBPROTOBUF_EXPORT uint32 ghtonl(uint32 x); 1173a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1174a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson// =================================================================== 1175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Shutdown support. 1176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Shut down the entire protocol buffers library, deleting all static-duration 1178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// objects allocated by the library or by generated .pb.cc files. 1179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// There are two reasons you might want to call this: 1181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * You use a draconian definition of "memory leak" in which you expect 1182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// every single malloc() to have a corresponding free(), even for objects 1183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// which live until program exit. 1184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * You are writing a dynamically-loaded library which needs to clean up 1185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// after itself when the library is unloaded. 1186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 1187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// It is safe to call this multiple times. However, it is not safe to use 1188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// any other part of the protocol buffers library after 1189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ShutdownProtobufLibrary() has been called. 1190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT void ShutdownProtobufLibrary(); 1191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillenamespace internal { 1193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Register a function to be called when ShutdownProtocolBuffers() is called. 1195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleLIBPROTOBUF_EXPORT void OnShutdown(void (*func)()); 1196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace internal 1198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1199a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#if PROTOBUF_USE_EXCEPTIONS 1200a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonclass FatalException : public std::exception { 1201a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson public: 1202a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson FatalException(const char* filename, int line, const std::string& message) 1203a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson : filename_(filename), line_(line), message_(message) {} 1204a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson virtual ~FatalException() throw(); 1205a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1206a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson virtual const char* what() const throw(); 1207a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1208a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson const char* filename() const { return filename_; } 1209a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson int line() const { return line_; } 1210a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson const std::string& message() const { return message_; } 1211a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1212a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson private: 1213a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson const char* filename_; 1214a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson const int line_; 1215a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson const std::string message_; 1216a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson}; 1217a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson#endif 1218a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1219a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson// This is at the end of the file instead of the beginning to work around a bug 1220a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson// in some versions of MSVC. 1221a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidsonusing namespace std; // Don't do this at home, kids. 1222a3b2a6da25a76f17c73d31def3952feb0fd2296eJeff Davidson 1223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace protobuf 1224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} // namespace google 1225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 1226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GOOGLE_PROTOBUF_COMMON_H__ 1227