text: ﻿// 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 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 GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
  #define GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
  
  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
  
  #endif  // GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
  