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. 80 template <typename T, size_t N> 81 char (&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 87 template <typename T, size_t N> 88 char (&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