include/ceres/internal/manual_constructor.h

   1 // Ceres Solver - A fast non-linear least squares minimizer
   2 // Copyright 2015 Google Inc. All rights reserved.
   3 // http://ceres-solver.org/
   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 // Author: kenton@google.com (Kenton Varda)
  30 //
  31 // ManualConstructor statically-allocates space in which to store some
  32 // object, but does not initialize it.  You can then call the constructor
  33 // and destructor for the object yourself as you see fit.  This is useful
  34 // for memory management optimizations, where you want to initialize and
  35 // destroy an object multiple times but only allocate it once.
  36 //
  37 // (When I say ManualConstructor statically allocates space, I mean that
  38 // the ManualConstructor object itself is forced to be the right size.)
  39
  40 #ifndef CERES_PUBLIC_INTERNAL_MANUAL_CONSTRUCTOR_H_
  41 #define CERES_PUBLIC_INTERNAL_MANUAL_CONSTRUCTOR_H_
  42
  43 #include <new>
  44
  45 namespace ceres {
  46 namespace internal {
  47
  48 // ------- Define CERES_ALIGNED_CHAR_ARRAY --------------------------------
  49
  50 #ifndef CERES_ALIGNED_CHAR_ARRAY
  51
  52 // Because MSVC and older GCCs require that the argument to their alignment
  53 // construct to be a literal constant integer, we use a template instantiated
  54 // at all the possible powers of two.
  55 template<int alignment, int size> struct AlignType { };
  56 template<int size> struct AlignType<0, size> { typedef char result[size]; };
  57
  58 #if !defined(CERES_ALIGN_ATTRIBUTE)
  59 #define CERES_ALIGNED_CHAR_ARRAY you_must_define_CERES_ALIGNED_CHAR_ARRAY_for_your_compiler
  60 #else  // !defined(CERES_ALIGN_ATTRIBUTE)
  61
  62 #define CERES_ALIGN_TYPE_TEMPLATE(X) \
  63   template<int size> struct AlignType<X, size> { \
  64     typedef CERES_ALIGN_ATTRIBUTE(X) char result[size]; \
  65   }
  66
  67 CERES_ALIGN_TYPE_TEMPLATE(1);
  68 CERES_ALIGN_TYPE_TEMPLATE(2);
  69 CERES_ALIGN_TYPE_TEMPLATE(4);
  70 CERES_ALIGN_TYPE_TEMPLATE(8);
  71 CERES_ALIGN_TYPE_TEMPLATE(16);
  72 CERES_ALIGN_TYPE_TEMPLATE(32);
  73 CERES_ALIGN_TYPE_TEMPLATE(64);
  74 CERES_ALIGN_TYPE_TEMPLATE(128);
  75 CERES_ALIGN_TYPE_TEMPLATE(256);
  76 CERES_ALIGN_TYPE_TEMPLATE(512);
  77 CERES_ALIGN_TYPE_TEMPLATE(1024);
  78 CERES_ALIGN_TYPE_TEMPLATE(2048);
  79 CERES_ALIGN_TYPE_TEMPLATE(4096);
  80 CERES_ALIGN_TYPE_TEMPLATE(8192);
  81 // Any larger and MSVC++ will complain.
  82
  83 #undef CERES_ALIGN_TYPE_TEMPLATE
  84
  85 #define CERES_ALIGNED_CHAR_ARRAY(T, Size) \
  86   typename AlignType<CERES_ALIGN_OF(T), sizeof(T) * Size>::result
  87
  88 #endif  // !defined(CERES_ALIGN_ATTRIBUTE)
  89
  90 #endif  // CERES_ALIGNED_CHAR_ARRAY
  91
  92 template <typename Type>
  93 class ManualConstructor {
  94  public:
  95   // No constructor or destructor because one of the most useful uses of
  96   // this class is as part of a union, and members of a union cannot have
  97   // constructors or destructors.  And, anyway, the whole point of this
  98   // class is to bypass these.
  99
 100   inline Type* get() {
 101     return reinterpret_cast<Type*>(space_);
 102   }
 103   inline const Type* get() const  {
 104     return reinterpret_cast<const Type*>(space_);
 105   }
 106
 107   inline Type* operator->() { return get(); }
 108   inline const Type* operator->() const { return get(); }
 109
 110   inline Type& operator*() { return *get(); }
 111   inline const Type& operator*() const { return *get(); }
 112
 113   // This is needed to get around the strict aliasing warning GCC generates.
 114   inline void* space() {
 115     return reinterpret_cast<void*>(space_);
 116   }
 117
 118   // You can pass up to four constructor arguments as arguments of Init().
 119   inline void Init() {
 120     new(space()) Type;
 121   }
 122
 123   template <typename T1>
 124   inline void Init(const T1& p1) {
 125     new(space()) Type(p1);
 126   }
 127
 128   template <typename T1, typename T2>
 129   inline void Init(const T1& p1, const T2& p2) {
 130     new(space()) Type(p1, p2);
 131   }
 132
 133   template <typename T1, typename T2, typename T3>
 134   inline void Init(const T1& p1, const T2& p2, const T3& p3) {
 135     new(space()) Type(p1, p2, p3);
 136   }
 137
 138   template <typename T1, typename T2, typename T3, typename T4>
 139   inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4) {
 140     new(space()) Type(p1, p2, p3, p4);
 141   }
 142
 143   template <typename T1, typename T2, typename T3, typename T4, typename T5>
 144   inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4,
 145                    const T5& p5) {
 146     new(space()) Type(p1, p2, p3, p4, p5);
 147   }
 148
 149   template <typename T1, typename T2, typename T3, typename T4, typename T5,
 150             typename T6>
 151   inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4,
 152                    const T5& p5, const T6& p6) {
 153     new(space()) Type(p1, p2, p3, p4, p5, p6);
 154   }
 155
 156   template <typename T1, typename T2, typename T3, typename T4, typename T5,
 157             typename T6, typename T7>
 158   inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4,
 159                    const T5& p5, const T6& p6, const T7& p7) {
 160     new(space()) Type(p1, p2, p3, p4, p5, p6, p7);
 161   }
 162
 163   template <typename T1, typename T2, typename T3, typename T4, typename T5,
 164             typename T6, typename T7, typename T8>
 165   inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4,
 166                    const T5& p5, const T6& p6, const T7& p7, const T8& p8) {
 167     new(space()) Type(p1, p2, p3, p4, p5, p6, p7, p8);
 168   }
 169
 170   template <typename T1, typename T2, typename T3, typename T4, typename T5,
 171             typename T6, typename T7, typename T8, typename T9>
 172   inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4,
 173                    const T5& p5, const T6& p6, const T7& p7, const T8& p8,
 174                    const T9& p9) {
 175     new(space()) Type(p1, p2, p3, p4, p5, p6, p7, p8, p9);
 176   }
 177
 178   template <typename T1, typename T2, typename T3, typename T4, typename T5,
 179             typename T6, typename T7, typename T8, typename T9, typename T10>
 180   inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4,
 181                    const T5& p5, const T6& p6, const T7& p7, const T8& p8,
 182                    const T9& p9, const T10& p10) {
 183     new(space()) Type(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
 184   }
 185
 186   template <typename T1, typename T2, typename T3, typename T4, typename T5,
 187             typename T6, typename T7, typename T8, typename T9, typename T10,
 188             typename T11>
 189   inline void Init(const T1& p1, const T2& p2, const T3& p3, const T4& p4,
 190                    const T5& p5, const T6& p6, const T7& p7, const T8& p8,
 191                    const T9& p9, const T10& p10, const T11& p11) {
 192     new(space()) Type(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
 193   }
 194
 195   inline void Destroy() {
 196     get()->~Type();
 197   }
 198
 199  private:
 200   CERES_ALIGNED_CHAR_ARRAY(Type, 1) space_;
 201 };
 202
 203 #undef CERES_ALIGNED_CHAR_ARRAY
 204
 205 }  // namespace internal
 206 }  // namespace ceres
 207
 208 #endif  // CERES_PUBLIC_INTERNAL_MANUAL_CONSTRUCTOR_H_