1// Ceres Solver - A fast non-linear least squares minimizer
2// Copyright 2010, 2011, 2012 Google Inc. All rights reserved.
3// http://code.google.com/p/ceres-solver/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are met:
7//
8// * Redistributions of source code must retain the above copyright notice,
9//   this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above copyright notice,
11//   this list of conditions and the following disclaimer in the documentation
12//   and/or other materials provided with the distribution.
13// * Neither the name of Google Inc. nor the names of its contributors may be
14//   used to endorse or promote products derived from this software without
15//   specific prior written permission.
16//
17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27// POSSIBILITY OF SUCH DAMAGE.
28//
29//
30// Various Google-specific macros.
31//
32// This code is compiled directly on many platforms, including client
33// platforms like Windows, Mac, and embedded systems.  Before making
34// any changes here, make sure that you're not breaking any platforms.
35
36#ifndef CERES_PUBLIC_INTERNAL_MACROS_H_
37#define CERES_PUBLIC_INTERNAL_MACROS_H_
38
39#include <cstddef>  // For size_t.
40
41// A macro to disallow the copy constructor and operator= functions
42// This should be used in the private: declarations for a class
43//
44// For disallowing only assign or copy, write the code directly, but declare
45// the intend in a comment, for example:
46//
47//   void operator=(const TypeName&);  // _DISALLOW_ASSIGN
48
49// Note, that most uses of CERES_DISALLOW_ASSIGN and CERES_DISALLOW_COPY
50// are broken semantically, one should either use disallow both or
51// neither. Try to avoid these in new code.
52#define CERES_DISALLOW_COPY_AND_ASSIGN(TypeName) \
53  TypeName(const TypeName&);               \
54  void operator=(const TypeName&)
55
56// A macro to disallow all the implicit constructors, namely the
57// default constructor, copy constructor and operator= functions.
58//
59// This should be used in the private: declarations for a class
60// that wants to prevent anyone from instantiating it. This is
61// especially useful for classes containing only static methods.
62#define CERES_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
63  TypeName();                                    \
64  CERES_DISALLOW_COPY_AND_ASSIGN(TypeName)
65
66// The arraysize(arr) macro returns the # of elements in an array arr.
67// The expression is a compile-time constant, and therefore can be
68// used in defining new arrays, for example.  If you use arraysize on
69// a pointer by mistake, you will get a compile-time error.
70//
71// One caveat is that arraysize() doesn't accept any array of an
72// anonymous type or a type defined inside a function.  In these rare
73// cases, you have to use the unsafe ARRAYSIZE() macro below.  This is
74// due to a limitation in C++'s template system.  The limitation might
75// eventually be removed, but it hasn't happened yet.
76
77// This template function declaration is used in defining arraysize.
78// Note that the function doesn't need an implementation, as we only
79// use its type.
80template <typename T, size_t N>
81char (&ArraySizeHelper(T (&array)[N]))[N];
82
83// That gcc wants both of these prototypes seems mysterious. VC, for
84// its part, can't decide which to use (another mystery). Matching of
85// template overloads: the final frontier.
86#ifndef _WIN32
87template <typename T, size_t N>
88char (&ArraySizeHelper(const T (&array)[N]))[N];
89#endif
90
91#define arraysize(array) (sizeof(ArraySizeHelper(array)))
92
93// ARRAYSIZE performs essentially the same calculation as arraysize,
94// but can be used on anonymous types or types defined inside
95// functions.  It's less safe than arraysize as it accepts some
96// (although not all) pointers.  Therefore, you should use arraysize
97// whenever possible.
98//
99// The expression ARRAYSIZE(a) is a compile-time constant of type
100// size_t.
101//
102// ARRAYSIZE catches a few type errors.  If you see a compiler error
103//
104//   "warning: division by zero in ..."
105//
106// when using ARRAYSIZE, you are (wrongfully) giving it a pointer.
107// You should only use ARRAYSIZE on statically allocated arrays.
108//
109// The following comments are on the implementation details, and can
110// be ignored by the users.
111//
112// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
113// the array) and sizeof(*(arr)) (the # of bytes in one array
114// element).  If the former is divisible by the latter, perhaps arr is
115// indeed an array, in which case the division result is the # of
116// elements in the array.  Otherwise, arr cannot possibly be an array,
117// and we generate a compiler error to prevent the code from
118// compiling.
119//
120// Since the size of bool is implementation-defined, we need to cast
121// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
122// result has type size_t.
123//
124// This macro is not perfect as it wrongfully accepts certain
125// pointers, namely where the pointer size is divisible by the pointee
126// size.  Since all our code has to go through a 32-bit compiler,
127// where a pointer is 4 bytes, this means all pointers to a type whose
128// size is 3 or greater than 4 will be (righteously) rejected.
129//
130// Kudos to Jorg Brown for this simple and elegant implementation.
131//
132// - wan 2005-11-16
133//
134// Starting with Visual C++ 2005, WinNT.h includes ARRAYSIZE. However,
135// the definition comes from the over-broad windows.h header that
136// introduces a macro, ERROR, that conflicts with the logging framework
137// that Ceres uses. Instead, rename ARRAYSIZE to CERES_ARRAYSIZE.
138#define CERES_ARRAYSIZE(a)                              \
139  ((sizeof(a) / sizeof(*(a))) /                         \
140   static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
141
142// Tell the compiler to warn about unused return values for functions
143// declared with this macro.  The macro should be used on function
144// declarations following the argument list:
145//
146//   Sprocket* AllocateSprocket() MUST_USE_RESULT;
147//
148#if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) \
149  && !defined(COMPILER_ICC)
150#define CERES_MUST_USE_RESULT __attribute__ ((warn_unused_result))
151#else
152#define CERES_MUST_USE_RESULT
153#endif
154
155// Platform independent macros to get aligned memory allocations.
156// For example
157//
158//   MyFoo my_foo CERES_ALIGN_ATTRIBUTE(16);
159//
160// Gives us an instance of MyFoo which is aligned at a 16 byte
161// boundary.
162#if defined(_MSC_VER)
163#define CERES_ALIGN_ATTRIBUTE(n) __declspec(align(n))
164#define CERES_ALIGN_OF(T) __alignof(T)
165#elif defined(__GNUC__)
166#define CERES_ALIGN_ATTRIBUTE(n) __attribute__((aligned(n)))
167#define CERES_ALIGN_OF(T) __alignof(T)
168#endif
169
170#endif  // CERES_PUBLIC_INTERNAL_MACROS_H_
171