| // Copyright 2005 Google Inc. | |
| // All rights reserved. | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are | |
| // met: | |
| // | |
| // * Redistributions of source code must retain the above copyright | |
| // notice, this list of conditions and the following disclaimer. | |
| // * Redistributions in binary form must reproduce the above | |
| // copyright notice, this list of conditions and the following disclaimer | |
| // in the documentation and/or other materials provided with the | |
| // distribution. | |
| // * Neither the name of Google Inc. nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| // ---- | |
| // Author: lar@google.com (Laramie Leavitt) | |
| // | |
| // 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 chosen 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. | |
| // | |
| namespace google { | |
| namespace protobuf { | |
| namespace internal { | |
| // Types small_ and big_ are guaranteed such that sizeof(small_) < | |
| // sizeof(big_) | |
| typedef char small_; | |
| struct big_ { | |
| char dummy[2]; | |
| }; | |
| // Identity metafunction. | |
| template <class T> | |
| struct identity_ { | |
| typedef T type; | |
| }; | |
| // 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". | |
| // | |
| // New code should prefer base::is_same, defined in base/type_traits.h. | |
| // It is functionally identical, but is_same is the standard spelling. | |
| 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)> { | |
| }; | |
| } // namespace internal | |
| } // namespace protobuf | |
| } // namespace google | |