| // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Template metaprogramming utility functions. |
| // |
| // This code is compiled directly on many platforms, including client |
| // platforms like Windows, Mac, and embedded systems. Before making |
| // any changes here, make sure that you're not breaking any platforms. |
| // |
| // The names choosen here reflect those used in tr1 and the boost::mpl |
| // library, there are similar operations used in the Loki library as |
| // well. I prefer the boost names for 2 reasons: |
| // 1. I think that portions of the Boost libraries are more likely to |
| // be included in the c++ standard. |
| // 2. It is not impossible that some of the boost libraries will be |
| // included in our own build in the future. |
| // Both of these outcomes means that we may be able to directly replace |
| // some of these with boost equivalents. |
| // |
| #ifndef BASE_TEMPLATE_UTIL_H_ |
| #define BASE_TEMPLATE_UTIL_H_ |
| |
| namespace base { |
| |
| // Types small_ and big_ are guaranteed such that sizeof(small_) < |
| // sizeof(big_) |
| typedef char small_; |
| |
| struct big_ { |
| char dummy[2]; |
| }; |
| |
| // integral_constant, defined in tr1, is a wrapper for an integer |
| // value. We don't really need this generality; we could get away |
| // with hardcoding the integer type to bool. We use the fully |
| // general integer_constant for compatibility with tr1. |
| |
| template<class T, T v> |
| struct integral_constant { |
| static const T value = v; |
| typedef T value_type; |
| typedef integral_constant<T, v> type; |
| }; |
| |
| template <class T, T v> const T integral_constant<T, v>::value; |
| |
| |
| // Abbreviations: true_type and false_type are structs that represent boolean |
| // true and false values. Also define the boost::mpl versions of those names, |
| // true_ and false_. |
| typedef integral_constant<bool, true> true_type; |
| typedef integral_constant<bool, false> false_type; |
| typedef true_type true_; |
| typedef false_type false_; |
| |
| // if_ is a templatized conditional statement. |
| // if_<cond, A, B> is a compile time evaluation of cond. |
| // if_<>::type contains A if cond is true, B otherwise. |
| template<bool cond, typename A, typename B> |
| struct if_{ |
| typedef A type; |
| }; |
| |
| template<typename A, typename B> |
| struct if_<false, A, B> { |
| typedef B type; |
| }; |
| |
| |
| // type_equals_ is a template type comparator, similar to Loki IsSameType. |
| // type_equals_<A, B>::value is true iff "A" is the same type as "B". |
| template<typename A, typename B> |
| struct type_equals_ : public false_ { |
| }; |
| |
| template<typename A> |
| struct type_equals_<A, A> : public true_ { |
| }; |
| |
| // and_ is a template && operator. |
| // and_<A, B>::value evaluates "A::value && B::value". |
| template<typename A, typename B> |
| struct and_ : public integral_constant<bool, (A::value && B::value)> { |
| }; |
| |
| // or_ is a template || operator. |
| // or_<A, B>::value evaluates "A::value || B::value". |
| template<typename A, typename B> |
| struct or_ : public integral_constant<bool, (A::value || B::value)> { |
| }; |
| |
| |
| } // Close namespace base |
| |
| #endif // BASE_TEMPLATE_UTIL_H_ |