src/third_party/protobuf/src/google/protobuf/stubs/macros.h - cobalt - Git at Google

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #ifndef GOOGLE_PROTOBUF_MACROS_H__
 #define GOOGLE_PROTOBUF_MACROS_H__

 #include <google/protobuf/stubs/port.h>

 namespace google {
 namespace protobuf {

 #undef GOOGLE_DISALLOW_EVIL_CONSTRUCTORS
 #define GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeName)    \
   TypeName(const TypeName&);                           \
   void operator=(const TypeName&)

 #undef GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS
 #define GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
   TypeName();                                           \
   TypeName(const TypeName&);                            \
   void operator=(const TypeName&)

 // ===================================================================
 // from google3/base/basictypes.h

 // The GOOGLE_ARRAYSIZE(arr) macro returns the # of elements in an array arr.
 // The expression is a compile-time constant, and therefore can be
 // used in defining new arrays, for example.
 //
 // GOOGLE_ARRAYSIZE catches a few type errors.  If you see a compiler error
 //
 //   "warning: division by zero in ..."
 //
 // when using GOOGLE_ARRAYSIZE, you are (wrongfully) giving it a pointer.
 // You should only use GOOGLE_ARRAYSIZE on statically allocated arrays.
 //
 // The following comments are on the implementation details, and can
 // be ignored by the users.
 //
 // ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
 // the array) and sizeof(*(arr)) (the # of bytes in one array
 // element).  If the former is divisible by the latter, perhaps arr is
 // indeed an array, in which case the division result is the # of
 // elements in the array.  Otherwise, arr cannot possibly be an array,
 // and we generate a compiler error to prevent the code from
 // compiling.
 //
 // Since the size of bool is implementation-defined, we need to cast
 // !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
 // result has type size_t.
 //
 // This macro is not perfect as it wrongfully accepts certain
 // pointers, namely where the pointer size is divisible by the pointee
 // size.  Since all our code has to go through a 32-bit compiler,
 // where a pointer is 4 bytes, this means all pointers to a type whose
 // size is 3 or greater than 4 will be (righteously) rejected.
 //
 // Kudos to Jorg Brown for this simple and elegant implementation.

 #undef GOOGLE_ARRAYSIZE
 #define GOOGLE_ARRAYSIZE(a) \
   ((sizeof(a) / sizeof(*(a))) / \
    static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

 // The COMPILE_ASSERT macro can be used to verify that a compile time
 // expression is true. For example, you could use it to verify the
 // size of a static array:
 //
 //   COMPILE_ASSERT(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
 //                  content_type_names_incorrect_size);
 //
 // or to make sure a struct is smaller than a certain size:
 //
 //   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
 //
 // The second argument to the macro is the name of the variable. If
 // the expression is false, most compilers will issue a warning/error
 // containing the name of the variable.

 namespace internal {

 template <bool>
 struct CompileAssert {
 };

 }  // namespace internal

 #undef GOOGLE_COMPILE_ASSERT
 #if __cplusplus >= 201103L
 #define GOOGLE_COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
 #else
 #define GOOGLE_COMPILE_ASSERT(expr, msg) \
   ::google::protobuf::internal::CompileAssert<(bool(expr))> \
           msg[bool(expr) ? 1 : -1]; \
   (void)msg
 // Implementation details of COMPILE_ASSERT:
 //
 // - COMPILE_ASSERT works by defining an array type that has -1
 //   elements (and thus is invalid) when the expression is false.
 //
 // - The simpler definition
 //
 //     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
 //
 //   does not work, as gcc supports variable-length arrays whose sizes
 //   are determined at run-time (this is gcc's extension and not part
 //   of the C++ standard).  As a result, gcc fails to reject the
 //   following code with the simple definition:
 //
 //     int foo;
 //     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
 //                               // not a compile-time constant.
 //
 // - By using the type CompileAssert<(bool(expr))>, we ensures that
 //   expr is a compile-time constant.  (Template arguments must be
 //   determined at compile-time.)
 //
 // - The outter parentheses in CompileAssert<(bool(expr))> are necessary
 //   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
 //
 //     CompileAssert<bool(expr)>
 //
 //   instead, these compilers will refuse to compile
 //
 //     COMPILE_ASSERT(5 > 0, some_message);
 //
 //   (They seem to think the ">" in "5 > 0" marks the end of the
 //   template argument list.)
 //
 // - The array size is (bool(expr) ? 1 : -1), instead of simply
 //
 //     ((expr) ? 1 : -1).
 //
 //   This is to avoid running into a bug in MS VC 7.1, which
 //   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
 #endif  // __cplusplus >= 201103L

 }  // namespace protobuf
 }  // namespace google

 #endif  // GOOGLE_PROTOBUF_MACROS_H__
	// Protocol Buffers - Google's data interchange format
	// Copyright 2008 Google Inc. All rights reserved.
	// https://developers.google.com/protocol-buffers/
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#ifndef GOOGLE_PROTOBUF_MACROS_H__
	#define GOOGLE_PROTOBUF_MACROS_H__

	#include <google/protobuf/stubs/port.h>

	namespace google {
	namespace protobuf {

	#undef GOOGLE_DISALLOW_EVIL_CONSTRUCTORS
	#define GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeName) \
	TypeName(const TypeName&); \
	void operator=(const TypeName&)

	#undef GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS
	#define GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
	TypeName(); \
	TypeName(const TypeName&); \
	void operator=(const TypeName&)

	// ===================================================================
	// from google3/base/basictypes.h

	// The GOOGLE_ARRAYSIZE(arr) macro returns the # of elements in an array arr.
	// The expression is a compile-time constant, and therefore can be
	// used in defining new arrays, for example.
	//
	// GOOGLE_ARRAYSIZE catches a few type errors. If you see a compiler error
	//
	// "warning: division by zero in ..."
	//
	// when using GOOGLE_ARRAYSIZE, you are (wrongfully) giving it a pointer.
	// You should only use GOOGLE_ARRAYSIZE on statically allocated arrays.
	//
	// The following comments are on the implementation details, and can
	// be ignored by the users.
	//
	// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
	// the array) and sizeof(*(arr)) (the # of bytes in one array
	// element). If the former is divisible by the latter, perhaps arr is
	// indeed an array, in which case the division result is the # of
	// elements in the array. Otherwise, arr cannot possibly be an array,
	// and we generate a compiler error to prevent the code from
	// compiling.
	//
	// Since the size of bool is implementation-defined, we need to cast
	// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
	// result has type size_t.
	//
	// This macro is not perfect as it wrongfully accepts certain
	// pointers, namely where the pointer size is divisible by the pointee
	// size. Since all our code has to go through a 32-bit compiler,
	// where a pointer is 4 bytes, this means all pointers to a type whose
	// size is 3 or greater than 4 will be (righteously) rejected.
	//
	// Kudos to Jorg Brown for this simple and elegant implementation.

	#undef GOOGLE_ARRAYSIZE
	#define GOOGLE_ARRAYSIZE(a) \
	((sizeof(a) / sizeof(*(a))) / \
	static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

	// The COMPILE_ASSERT macro can be used to verify that a compile time
	// expression is true. For example, you could use it to verify the
	// size of a static array:
	//
	// COMPILE_ASSERT(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
	// content_type_names_incorrect_size);
	//
	// or to make sure a struct is smaller than a certain size:
	//
	// COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
	//
	// The second argument to the macro is the name of the variable. If
	// the expression is false, most compilers will issue a warning/error
	// containing the name of the variable.

	namespace internal {

	template <bool>
	struct CompileAssert {
	};

	} // namespace internal

	#undef GOOGLE_COMPILE_ASSERT
	#if __cplusplus >= 201103L
	#define GOOGLE_COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
	#else
	#define GOOGLE_COMPILE_ASSERT(expr, msg) \
	::google::protobuf::internal::CompileAssert<(bool(expr))> \
	msg[bool(expr) ? 1 : -1]; \
	(void)msg
	// Implementation details of COMPILE_ASSERT:
	//
	// - COMPILE_ASSERT works by defining an array type that has -1
	// elements (and thus is invalid) when the expression is false.
	//
	// - The simpler definition
	//
	// #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
	//
	// does not work, as gcc supports variable-length arrays whose sizes
	// are determined at run-time (this is gcc's extension and not part
	// of the C++ standard). As a result, gcc fails to reject the
	// following code with the simple definition:
	//
	// int foo;
	// COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
	// // not a compile-time constant.
	//
	// - By using the type CompileAssert<(bool(expr))>, we ensures that
	// expr is a compile-time constant. (Template arguments must be
	// determined at compile-time.)
	//
	// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
	// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written
	//
	// CompileAssert<bool(expr)>
	//
	// instead, these compilers will refuse to compile
	//
	// COMPILE_ASSERT(5 > 0, some_message);
	//
	// (They seem to think the ">" in "5 > 0" marks the end of the
	// template argument list.)
	//
	// - The array size is (bool(expr) ? 1 : -1), instead of simply
	//
	// ((expr) ? 1 : -1).
	//
	// This is to avoid running into a bug in MS VC 7.1, which
	// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
	#endif // __cplusplus >= 201103L

	} // namespace protobuf
	} // namespace google

	#endif // GOOGLE_PROTOBUF_MACROS_H__