139 lines
4.7 KiB
C++
139 lines
4.7 KiB
C++
// 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_
|