THUAI6/CAPI/cpp/grpc/include/google/protobuf/stubs/template_util.h

// 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.
//
#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_