1 /* 2 * Copyright 2017 Google Inc. All rights reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef FLATBUFFERS_STL_EMULATION_H_ 18 #define FLATBUFFERS_STL_EMULATION_H_ 19 20 // clang-format off 21 22 #include <string> 23 #include <type_traits> 24 #include <vector> 25 #include <memory> 26 #include <limits> 27 28 #if defined(_STLPORT_VERSION) && !defined(FLATBUFFERS_CPP98_STL) 29 #define FLATBUFFERS_CPP98_STL 30 #endif // defined(_STLPORT_VERSION) && !defined(FLATBUFFERS_CPP98_STL) 31 32 #if defined(FLATBUFFERS_CPP98_STL) 33 #include <cctype> 34 #endif // defined(FLATBUFFERS_CPP98_STL) 35 36 // Check if we can use template aliases 37 // Not possible if Microsoft Compiler before 2012 38 // Possible is the language feature __cpp_alias_templates is defined well 39 // Or possible if the C++ std is C+11 or newer 40 #if (defined(_MSC_VER) && _MSC_VER > 1700 /* MSVC2012 */) \ 41 || (defined(__cpp_alias_templates) && __cpp_alias_templates >= 200704) \ 42 || (defined(__cplusplus) && __cplusplus >= 201103L) 43 #define FLATBUFFERS_TEMPLATES_ALIASES 44 #endif 45 46 // This header provides backwards compatibility for C++98 STLs like stlport. 47 namespace flatbuffers { 48 49 // Retrieve ::back() from a string in a way that is compatible with pre C++11 50 // STLs (e.g stlport). string_back(std::string & value)51 inline char& string_back(std::string &value) { 52 return value[value.length() - 1]; 53 } 54 string_back(const std::string & value)55 inline char string_back(const std::string &value) { 56 return value[value.length() - 1]; 57 } 58 59 // Helper method that retrieves ::data() from a vector in a way that is 60 // compatible with pre C++11 STLs (e.g stlport). vector_data(std::vector<T> & vector)61 template <typename T> inline T *vector_data(std::vector<T> &vector) { 62 // In some debug environments, operator[] does bounds checking, so &vector[0] 63 // can't be used. 64 return vector.empty() ? nullptr : &vector[0]; 65 } 66 vector_data(const std::vector<T> & vector)67 template <typename T> inline const T *vector_data( 68 const std::vector<T> &vector) { 69 return vector.empty() ? nullptr : &vector[0]; 70 } 71 72 template <typename T, typename V> vector_emplace_back(std::vector<T> * vector,V && data)73 inline void vector_emplace_back(std::vector<T> *vector, V &&data) { 74 #if defined(FLATBUFFERS_CPP98_STL) 75 vector->push_back(data); 76 #else 77 vector->emplace_back(std::forward<V>(data)); 78 #endif // defined(FLATBUFFERS_CPP98_STL) 79 } 80 81 #ifndef FLATBUFFERS_CPP98_STL 82 #if defined(FLATBUFFERS_TEMPLATES_ALIASES) 83 template <typename T> 84 using numeric_limits = std::numeric_limits<T>; 85 #else 86 template <typename T> class numeric_limits : 87 public std::numeric_limits<T> {}; 88 #endif // defined(FLATBUFFERS_TEMPLATES_ALIASES) 89 #else 90 template <typename T> class numeric_limits : 91 public std::numeric_limits<T> { 92 public: 93 // Android NDK fix. lowest()94 static T lowest() { 95 return std::numeric_limits<T>::min(); 96 } 97 }; 98 99 template <> class numeric_limits<float> : 100 public std::numeric_limits<float> { 101 public: lowest()102 static float lowest() { return -FLT_MAX; } 103 }; 104 105 template <> class numeric_limits<double> : 106 public std::numeric_limits<double> { 107 public: lowest()108 static double lowest() { return -DBL_MAX; } 109 }; 110 111 template <> class numeric_limits<unsigned long long> { 112 public: min()113 static unsigned long long min() { return 0ULL; } max()114 static unsigned long long max() { return ~0ULL; } lowest()115 static unsigned long long lowest() { 116 return numeric_limits<unsigned long long>::min(); 117 } 118 }; 119 120 template <> class numeric_limits<long long> { 121 public: min()122 static long long min() { 123 return static_cast<long long>(1ULL << ((sizeof(long long) << 3) - 1)); 124 } max()125 static long long max() { 126 return static_cast<long long>( 127 (1ULL << ((sizeof(long long) << 3) - 1)) - 1); 128 } lowest()129 static long long lowest() { 130 return numeric_limits<long long>::min(); 131 } 132 }; 133 #endif // FLATBUFFERS_CPP98_STL 134 135 #if defined(FLATBUFFERS_TEMPLATES_ALIASES) 136 #ifndef FLATBUFFERS_CPP98_STL 137 template <typename T> using is_scalar = std::is_scalar<T>; 138 template <typename T, typename U> using is_same = std::is_same<T,U>; 139 template <typename T> using is_floating_point = std::is_floating_point<T>; 140 template <typename T> using is_unsigned = std::is_unsigned<T>; 141 template <typename T> using make_unsigned = std::make_unsigned<T>; 142 #else 143 // Map C++ TR1 templates defined by stlport. 144 template <typename T> using is_scalar = std::tr1::is_scalar<T>; 145 template <typename T, typename U> using is_same = std::tr1::is_same<T,U>; 146 template <typename T> using is_floating_point = 147 std::tr1::is_floating_point<T>; 148 template <typename T> using is_unsigned = std::tr1::is_unsigned<T>; 149 // Android NDK doesn't have std::make_unsigned or std::tr1::make_unsigned. 150 template<typename T> struct make_unsigned { 151 static_assert(is_unsigned<T>::value, "Specialization not implemented!"); 152 using type = T; 153 }; 154 template<> struct make_unsigned<char> { using type = unsigned char; }; 155 template<> struct make_unsigned<short> { using type = unsigned short; }; 156 template<> struct make_unsigned<int> { using type = unsigned int; }; 157 template<> struct make_unsigned<long> { using type = unsigned long; }; 158 template<> 159 struct make_unsigned<long long> { using type = unsigned long long; }; 160 #endif // !FLATBUFFERS_CPP98_STL 161 #else 162 // MSVC 2010 doesn't support C++11 aliases. 163 template <typename T> struct is_scalar : public std::is_scalar<T> {}; 164 template <typename T, typename U> struct is_same : public std::is_same<T,U> {}; 165 template <typename T> struct is_floating_point : 166 public std::is_floating_point<T> {}; 167 template <typename T> struct is_unsigned : public std::is_unsigned<T> {}; 168 template <typename T> struct make_unsigned : public std::make_unsigned<T> {}; 169 #endif // defined(FLATBUFFERS_TEMPLATES_ALIASES) 170 171 #ifndef FLATBUFFERS_CPP98_STL 172 #if defined(FLATBUFFERS_TEMPLATES_ALIASES) 173 template <class T> using unique_ptr = std::unique_ptr<T>; 174 #else 175 // MSVC 2010 doesn't support C++11 aliases. 176 // We're manually "aliasing" the class here as we want to bring unique_ptr 177 // into the flatbuffers namespace. We have unique_ptr in the flatbuffers 178 // namespace we have a completely independent implemenation (see below) 179 // for C++98 STL implementations. 180 template <class T> class unique_ptr : public std::unique_ptr<T> { 181 public: 182 unique_ptr() {} 183 explicit unique_ptr(T* p) : std::unique_ptr<T>(p) {} 184 unique_ptr(std::unique_ptr<T>&& u) { *this = std::move(u); } 185 unique_ptr(unique_ptr&& u) { *this = std::move(u); } 186 unique_ptr& operator=(std::unique_ptr<T>&& u) { 187 std::unique_ptr<T>::reset(u.release()); 188 return *this; 189 } 190 unique_ptr& operator=(unique_ptr&& u) { 191 std::unique_ptr<T>::reset(u.release()); 192 return *this; 193 } 194 unique_ptr& operator=(T* p) { 195 return std::unique_ptr<T>::operator=(p); 196 } 197 }; 198 #endif // defined(FLATBUFFERS_TEMPLATES_ALIASES) 199 #else 200 // Very limited implementation of unique_ptr. 201 // This is provided simply to allow the C++ code generated from the default 202 // settings to function in C++98 environments with no modifications. 203 template <class T> class unique_ptr { 204 public: 205 typedef T element_type; 206 207 unique_ptr() : ptr_(nullptr) {} 208 explicit unique_ptr(T* p) : ptr_(p) {} 209 unique_ptr(unique_ptr&& u) : ptr_(nullptr) { reset(u.release()); } 210 unique_ptr(const unique_ptr& u) : ptr_(nullptr) { 211 reset(const_cast<unique_ptr*>(&u)->release()); 212 } 213 ~unique_ptr() { reset(); } 214 215 unique_ptr& operator=(const unique_ptr& u) { 216 reset(const_cast<unique_ptr*>(&u)->release()); 217 return *this; 218 } 219 220 unique_ptr& operator=(unique_ptr&& u) { 221 reset(u.release()); 222 return *this; 223 } 224 225 unique_ptr& operator=(T* p) { 226 reset(p); 227 return *this; 228 } 229 230 const T& operator*() const { return *ptr_; } 231 T* operator->() const { return ptr_; } 232 T* get() const noexcept { return ptr_; } 233 explicit operator bool() const { return ptr_ != nullptr; } 234 235 // modifiers 236 T* release() { 237 T* value = ptr_; 238 ptr_ = nullptr; 239 return value; 240 } 241 242 void reset(T* p = nullptr) { 243 T* value = ptr_; 244 ptr_ = p; 245 if (value) delete value; 246 } 247 248 void swap(unique_ptr& u) { 249 T* temp_ptr = ptr_; 250 ptr_ = u.ptr_; 251 u.ptr_ = temp_ptr; 252 } 253 254 private: 255 T* ptr_; 256 }; 257 258 template <class T> bool operator==(const unique_ptr<T>& x, 259 const unique_ptr<T>& y) { 260 return x.get() == y.get(); 261 } 262 263 template <class T, class D> bool operator==(const unique_ptr<T>& x, 264 const D* y) { 265 return static_cast<D*>(x.get()) == y; 266 } 267 268 template <class T> bool operator==(const unique_ptr<T>& x, intptr_t y) { 269 return reinterpret_cast<intptr_t>(x.get()) == y; 270 } 271 #endif // !FLATBUFFERS_CPP98_STL 272 273 } // namespace flatbuffers 274 275 #endif // FLATBUFFERS_STL_EMULATION_H_ 276