// 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_; }

 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_