| // Copyright 2015 Google Inc. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #ifndef COBALT_BASE_TYPE_ID_H_ |
| #define COBALT_BASE_TYPE_ID_H_ |
| |
| #include "base/hash_tables.h" |
| |
| // This file introduces the template function GetTypeId<T>() as well as the |
| // class TypeId. GetTypeId<T>() will return a TypeId object that is unique |
| // to the type T passed as the template parameter. This can be used to |
| // implement run-time type identification on certain types without actually |
| // enabling RTTI on the compiler. |
| |
| // Some of this code is copied from gtest-internal.h. |
| |
| namespace base { |
| |
| namespace internal { |
| |
| template <typename T> |
| class TypeIdHelper { |
| public: |
| // dummy_ must not have a const type. Otherwise an overly eager |
| // compiler (e.g. MSVC 7.1 & 8.0) may try to merge |
| // TypeIdHelper<T>::dummy_ for different Ts as an "optimization". |
| static bool dummy_; |
| }; |
| |
| // The compiler is required to allocate a different |
| // TypeIdHelper<T>::dummy_ variable for each T used to instantiate |
| // the template. Therefore, the address of dummy_ is guaranteed to |
| // be unique. |
| template <typename T> |
| bool TypeIdHelper<T>::dummy_ = false; |
| |
| } // namespace internal |
| |
| class TypeId { |
| public: |
| bool operator==(const TypeId& other) const { return value_ == other.value_; } |
| bool operator!=(const TypeId& other) const { return !(*this == other); } |
| bool operator<(const TypeId& other) const { return value_ < other.value_; } |
| bool operator<=(const TypeId& other) const { return value_ <= other.value_; } |
| bool operator>(const TypeId& other) const { return value_ > other.value_; } |
| bool operator>=(const TypeId& other) const { return value_ >= other.value_; } |
| |
| private: |
| explicit TypeId(intptr_t value) : value_(value) {} |
| intptr_t value_; |
| template <typename T> friend TypeId GetTypeId(); |
| #if defined(BASE_HASH_USE_HASH_STRUCT) |
| friend struct BASE_HASH_NAMESPACE::hash<TypeId>; |
| #else |
| template <typename T, typename Predicate> |
| friend class BASE_HASH_NAMESPACE::hash_compare; |
| #endif |
| }; |
| |
| // GetTypeId<T>() returns the ID of type T. Different values will be |
| // returned for different types. Calling the function twice with the |
| // same type argument is guaranteed to return the same ID. |
| template <typename T> |
| TypeId GetTypeId() { |
| return |
| TypeId(reinterpret_cast<intptr_t>(&(internal::TypeIdHelper<T>::dummy_))); |
| } |
| |
| } // namespace base |
| |
| // Make TypeId usable as key in base::hash_map. |
| |
| namespace BASE_HASH_NAMESPACE { |
| |
| // |
| // GCC-flavored hash functor. |
| // |
| #if defined(BASE_HASH_USE_HASH_STRUCT) |
| |
| // Forward declaration in case <hash_fun.h> is not #include'd. |
| template <typename Key> |
| struct hash; |
| |
| template <> |
| struct hash<base::TypeId> { |
| size_t operator()(const base::TypeId& key) const { |
| return base_hash(key.value_); |
| } |
| |
| hash<intptr_t> base_hash; |
| }; |
| |
| // |
| // Dinkumware-flavored hash functor. |
| // |
| #else |
| |
| // Forward declaration in case <xhash> is not #include'd. |
| template <typename Key, typename Predicate> |
| class hash_compare; |
| |
| template <typename Predicate> |
| class hash_compare<base::TypeId, Predicate> { |
| public: |
| typedef hash_compare<intptr_t> BaseHashCompare; |
| |
| enum { |
| bucket_size = BaseHashCompare::bucket_size, |
| #if !defined(COMPILER_MSVC) |
| min_buckets = BaseHashCompare::min_buckets, |
| #endif |
| }; |
| |
| hash_compare() {} |
| |
| size_t operator()(const base::TypeId& key) const { |
| return base_hash_compare_(key.value_); |
| } |
| |
| bool operator()(const base::TypeId& lhs, |
| const base::TypeId& rhs) const { |
| return base_hash_compare_(lhs.value_, rhs.value_); |
| } |
| |
| private: |
| BaseHashCompare base_hash_compare_; |
| }; |
| |
| #endif |
| } // namespace BASE_HASH_NAMESPACE |
| |
| #endif // COBALT_BASE_TYPE_ID_H_ |