include/ceres/internal/macros.h - ceres-solver - Git at Google


            
            // Ceres Solver - A fast non-linear least squares minimizer

            
            // Copyright 2015 Google Inc. All rights reserved.

            
            // http://ceres-solver.org/

            
            //

            
            // 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.

            
            //

            
            //

            
            // Various Google-specific macros.

            
            //

            
            // This code is compiled directly on many platforms, including client

            
            // platforms like Windows, Mac, and embedded systems.  Before making

            
            // any changes here, make sure that you're not breaking any platforms.


            #ifndef CERES_PUBLIC_INTERNAL_MACROS_H_

            
            #define CERES_PUBLIC_INTERNAL_MACROS_H_


            #include <cstddef>  // For size_t.


            // A macro to disallow the copy constructor and operator= functions

            
            // This should be used in the private: declarations for a class

            
            //

            
            // For disallowing only assign or copy, write the code directly, but declare

            
            // the intend in a comment, for example:

            
            //

            
            //   void operator=(const TypeName&);  // _DISALLOW_ASSIGN


            // Note, that most uses of CERES_DISALLOW_ASSIGN and CERES_DISALLOW_COPY

            
            // are broken semantically, one should either use disallow both or

            
            // neither. Try to avoid these in new code.

            
            #define CERES_DISALLOW_COPY_AND_ASSIGN(TypeName) \

            
              TypeName(const TypeName&);               \

            
              void operator=(const TypeName&)


            // A macro to disallow all the implicit constructors, namely the

            
            // default constructor, copy constructor and operator= functions.

            
            //

            
            // This should be used in the private: declarations for a class

            
            // that wants to prevent anyone from instantiating it. This is

            
            // especially useful for classes containing only static methods.

            
            #define CERES_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \

            
              TypeName();                                    \

            
              CERES_DISALLOW_COPY_AND_ASSIGN(TypeName)


            // The 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.  If you use arraysize on

            
            // a pointer by mistake, you will get a compile-time error.

            
            //

            
            // One caveat is that arraysize() doesn't accept any array of an

            
            // anonymous type or a type defined inside a function.  In these rare

            
            // cases, you have to use the unsafe ARRAYSIZE() macro below.  This is

            
            // due to a limitation in C++'s template system.  The limitation might

            
            // eventually be removed, but it hasn't happened yet.


            // This template function declaration is used in defining arraysize.

            
            // Note that the function doesn't need an implementation, as we only

            
            // use its type.

            
            template <typename T, size_t N>

            
            char (&ArraySizeHelper(T (&array)[N]))[N];


            // That gcc wants both of these prototypes seems mysterious. VC, for

            
            // its part, can't decide which to use (another mystery). Matching of

            
            // template overloads: the final frontier.

            
            #ifndef _WIN32

            
            template <typename T, size_t N>

            
            char (&ArraySizeHelper(const T (&array)[N]))[N];

            
            #endif


            #define arraysize(array) (sizeof(ArraySizeHelper(array)))


            // ARRAYSIZE performs essentially the same calculation as arraysize,

            
            // but can be used on anonymous types or types defined inside

            
            // functions.  It's less safe than arraysize as it accepts some

            
            // (although not all) pointers.  Therefore, you should use arraysize

            
            // whenever possible.

            
            //

            
            // The expression ARRAYSIZE(a) is a compile-time constant of type

            
            // size_t.

            
            //

            
            // ARRAYSIZE catches a few type errors.  If you see a compiler error

            
            //

            
            //   "warning: division by zero in ..."

            
            //

            
            // when using ARRAYSIZE, you are (wrongfully) giving it a pointer.

            
            // You should only use 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.

            
            //

            
            // - wan 2005-11-16

            
            //

            
            // Starting with Visual C++ 2005, WinNT.h includes ARRAYSIZE. However,

            
            // the definition comes from the over-broad windows.h header that

            
            // introduces a macro, ERROR, that conflicts with the logging framework

            
            // that Ceres uses. Instead, rename ARRAYSIZE to CERES_ARRAYSIZE.

            
            #define CERES_ARRAYSIZE(a)                              \

            
              ((sizeof(a) / sizeof(*(a))) /                         \

            
               static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))


            // Tell the compiler to warn about unused return values for functions

            
            // declared with this macro.  The macro should be used on function

            
            // declarations following the argument list:

            
            //

            
            //   Sprocket* AllocateSprocket() MUST_USE_RESULT;

            
            //

            
            #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \

            
              && !defined(COMPILER_ICC)

            
            #define CERES_MUST_USE_RESULT __attribute__ ((warn_unused_result))

            
            #else

            
            #define CERES_MUST_USE_RESULT

            
            #endif


            // Platform independent macros to get aligned memory allocations.

            
            // For example

            
            //

            
            //   MyFoo my_foo CERES_ALIGN_ATTRIBUTE(16);

            
            //

            
            // Gives us an instance of MyFoo which is aligned at a 16 byte

            
            // boundary.

            
            #if defined(_MSC_VER)

            
            #define CERES_ALIGN_ATTRIBUTE(n) __declspec(align(n))

            
            #define CERES_ALIGN_OF(T) __alignof(T)

            
            #elif defined(__GNUC__)

            
            #define CERES_ALIGN_ATTRIBUTE(n) __attribute__((aligned(n)))

            
            #define CERES_ALIGN_OF(T) __alignof(T)

            
            #endif


            #endif  // CERES_PUBLIC_INTERNAL_MACROS_H_
	// Ceres Solver - A fast non-linear least squares minimizer
	// Copyright 2015 Google Inc. All rights reserved.
	// http://ceres-solver.org/
	//
	// 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.
	//
	//
	// Various Google-specific macros.
	//
	// This code is compiled directly on many platforms, including client
	// platforms like Windows, Mac, and embedded systems. Before making
	// any changes here, make sure that you're not breaking any platforms.

	#ifndef CERES_PUBLIC_INTERNAL_MACROS_H_
	#define CERES_PUBLIC_INTERNAL_MACROS_H_

	#include <cstddef> // For size_t.

	// A macro to disallow the copy constructor and operator= functions
	// This should be used in the private: declarations for a class
	//
	// For disallowing only assign or copy, write the code directly, but declare
	// the intend in a comment, for example:
	//
	// void operator=(const TypeName&); // _DISALLOW_ASSIGN

	// Note, that most uses of CERES_DISALLOW_ASSIGN and CERES_DISALLOW_COPY
	// are broken semantically, one should either use disallow both or
	// neither. Try to avoid these in new code.
	#define CERES_DISALLOW_COPY_AND_ASSIGN(TypeName) \
	TypeName(const TypeName&); \
	void operator=(const TypeName&)

	// A macro to disallow all the implicit constructors, namely the
	// default constructor, copy constructor and operator= functions.
	//
	// This should be used in the private: declarations for a class
	// that wants to prevent anyone from instantiating it. This is
	// especially useful for classes containing only static methods.
	#define CERES_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
	TypeName(); \
	CERES_DISALLOW_COPY_AND_ASSIGN(TypeName)

	// The 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. If you use arraysize on
	// a pointer by mistake, you will get a compile-time error.
	//
	// One caveat is that arraysize() doesn't accept any array of an
	// anonymous type or a type defined inside a function. In these rare
	// cases, you have to use the unsafe ARRAYSIZE() macro below. This is
	// due to a limitation in C++'s template system. The limitation might
	// eventually be removed, but it hasn't happened yet.

	// This template function declaration is used in defining arraysize.
	// Note that the function doesn't need an implementation, as we only
	// use its type.
	template <typename T, size_t N>
	char (&ArraySizeHelper(T (&array)[N]))[N];

	// That gcc wants both of these prototypes seems mysterious. VC, for
	// its part, can't decide which to use (another mystery). Matching of
	// template overloads: the final frontier.
	#ifndef _WIN32
	template <typename T, size_t N>
	char (&ArraySizeHelper(const T (&array)[N]))[N];
	#endif

	#define arraysize(array) (sizeof(ArraySizeHelper(array)))

	// ARRAYSIZE performs essentially the same calculation as arraysize,
	// but can be used on anonymous types or types defined inside
	// functions. It's less safe than arraysize as it accepts some
	// (although not all) pointers. Therefore, you should use arraysize
	// whenever possible.
	//
	// The expression ARRAYSIZE(a) is a compile-time constant of type
	// size_t.
	//
	// ARRAYSIZE catches a few type errors. If you see a compiler error
	//
	// "warning: division by zero in ..."
	//
	// when using ARRAYSIZE, you are (wrongfully) giving it a pointer.
	// You should only use 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.
	//
	// - wan 2005-11-16
	//
	// Starting with Visual C++ 2005, WinNT.h includes ARRAYSIZE. However,
	// the definition comes from the over-broad windows.h header that
	// introduces a macro, ERROR, that conflicts with the logging framework
	// that Ceres uses. Instead, rename ARRAYSIZE to CERES_ARRAYSIZE.
	#define CERES_ARRAYSIZE(a) \
	((sizeof(a) / sizeof(*(a))) / \
	static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

	// Tell the compiler to warn about unused return values for functions
	// declared with this macro. The macro should be used on function
	// declarations following the argument list:
	//
	// Sprocket* AllocateSprocket() MUST_USE_RESULT;
	//
	#if (__GNUC__ > 3 \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \
	&& !defined(COMPILER_ICC)
	#define CERES_MUST_USE_RESULT __attribute__ ((warn_unused_result))
	#else
	#define CERES_MUST_USE_RESULT
	#endif

	// Platform independent macros to get aligned memory allocations.
	// For example
	//
	// MyFoo my_foo CERES_ALIGN_ATTRIBUTE(16);
	//
	// Gives us an instance of MyFoo which is aligned at a 16 byte
	// boundary.
	#if defined(_MSC_VER)
	#define CERES_ALIGN_ATTRIBUTE(n) __declspec(align(n))
	#define CERES_ALIGN_OF(T) __alignof(T)
	#elif defined(__GNUC__)
	#define CERES_ALIGN_ATTRIBUTE(n) __attribute__((aligned(n)))
	#define CERES_ALIGN_OF(T) __alignof(T)
	#endif

	#endif // CERES_PUBLIC_INTERNAL_MACROS_H_