type_utils.hpp

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 
00003 // Copyright (C) 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the terms
00007 // of the GNU General Public License as published by the Free Software
00008 // Foundation; either version 3, or (at your option) any later
00009 // version.
00010 
00011 // This library is distributed in the hope that it will be useful, but
00012 // WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // General Public License for more details.
00015 
00016 // Under Section 7 of GPL version 3, you are granted additional
00017 // permissions described in the GCC Runtime Library Exception, version
00018 // 3.1, as published by the Free Software Foundation.
00019 
00020 // You should have received a copy of the GNU General Public License and
00021 // a copy of the GCC Runtime Library Exception along with this program;
00022 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00023 // <http://www.gnu.org/licenses/>.
00024 
00025 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
00026 
00027 // Permission to use, copy, modify, sell, and distribute this software
00028 // is hereby granted without fee, provided that the above copyright
00029 // notice appears in all copies, and that both that copyright notice
00030 // and this permission notice appear in supporting documentation. None
00031 // of the above authors, nor IBM Haifa Research Laboratories, make any
00032 // representation about the suitability of this software for any
00033 // purpose. It is provided "as is" without express or implied
00034 // warranty.
00035 
00036 /**
00037  * @file type_utils.hpp
00038  * Contains utilities for handnling types. All of these classes are based on
00039  *    "Modern C++" by Andrei Alxandrescu.
00040  */
00041 
00042 #ifndef PB_DS_TYPE_UTILS_HPP
00043 #define PB_DS_TYPE_UTILS_HPP
00044 
00045 #include <cstddef>
00046 #include <utility>
00047 #include <tr1/type_traits>
00048 #include <ext/type_traits.h>
00049 #include <ext/numeric_traits.h>
00050 
00051 namespace __gnu_pbds
00052 {
00053   namespace detail
00054   {
00055     using std::tr1::is_same;
00056     using std::tr1::is_const;
00057     using std::tr1::is_pointer;
00058     using std::tr1::is_reference;
00059     using std::tr1::is_fundamental;
00060     using std::tr1::is_member_object_pointer;
00061     using std::tr1::is_member_pointer;
00062     using std::tr1::is_base_of;
00063     using std::tr1::remove_const;
00064     using std::tr1::remove_reference;
00065 
00066     // Need integral_const<bool, true> <-> integral_const<int, 1>, so
00067     // because of this use the following typedefs instead of importing
00068     // std::tr1's.
00069     using std::tr1::integral_constant;
00070     typedef std::tr1::integral_constant<int, 1> true_type;
00071     typedef std::tr1::integral_constant<int, 0> false_type;
00072 
00073     using __gnu_cxx::__conditional_type;
00074     using __gnu_cxx::__numeric_traits;
00075 
00076     template<typename T>
00077     struct is_const_pointer
00078     {
00079       enum
00080     {
00081       value = is_const<T>::value && is_pointer<T>::value
00082     };
00083     };
00084 
00085     template<typename T>
00086     struct is_const_reference
00087     {
00088       enum
00089     {
00090       value = is_const<T>::value && is_reference<T>::value
00091     };
00092     };
00093 
00094     template<typename T>
00095     struct is_simple
00096     {
00097       enum
00098     {
00099       value = is_fundamental<typename remove_const<T>::type>::value 
00100       || is_pointer<typename remove_const<T>::type>::value 
00101       || is_member_pointer<T>::value 
00102     };
00103     };
00104 
00105     template<typename T>
00106     class is_pair
00107     {
00108     private:
00109       template<typename U>
00110       struct is_pair_imp
00111       {
00112     enum
00113       {
00114         value = 0
00115       };
00116       };
00117 
00118       template<typename U, typename V>
00119       struct is_pair_imp<std::pair<U,V> >
00120       {
00121     enum
00122       {
00123         value = 1
00124       };
00125       };
00126 
00127     public:
00128       enum
00129     {
00130       value = is_pair_imp<T>::value
00131     };
00132     };
00133 
00134     // Use C++0x's static_assert if possible.
00135 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00136 #define PB_DS_STATIC_ASSERT(UNIQUE, E)  static_assert(E, #UNIQUE)
00137 #else
00138     template<bool>
00139     struct __static_assert;
00140 
00141     template<>
00142     struct __static_assert<true>
00143     { };
00144 
00145     template<int>
00146     struct __static_assert_dumclass
00147     {
00148       enum
00149     {
00150       v = 1
00151     };
00152     };
00153 
00154 #define PB_DS_STATIC_ASSERT(UNIQUE, E)  \
00155     typedef __gnu_pbds::detail::__static_assert_dumclass<sizeof(__gnu_pbds::detail::__static_assert<bool(E)>)> UNIQUE##__static_assert_type
00156 
00157 #endif
00158 
00159     template<typename Type>
00160     struct type_to_type
00161     {
00162       typedef Type type;
00163     };
00164   } // namespace detail
00165 } // namespace __gnu_pbds
00166 
00167 #endif 

Generated on Thu Jul 23 21:16:29 2009 for libstdc++ by  doxygen 1.5.8