libstdc++-v3/include/tr1/tuple

   1 // class template tuple -*- C++ -*-
   2
   3 // Copyright (C) 2004, 2005 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 2, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 /** @file
  31 *  This is a TR1 C++ Library header.
  32 */
  33
  34 // Chris Jefferson <chris@bubblescope.net>
  35
  36 #ifndef _TUPLE
  37 #define _TUPLE 1
  38
  39 #include <tr1/utility>
  40 #include <tr1/ref_fwd.h>
  41
  42 namespace std
  43 {
  44 _GLIBCXX_BEGIN_NAMESPACE(tr1)
  45
  46  // An implementation specific class which is used in the tuple class
  47  // when the tuple is not maximum possible size.
  48  struct _NullClass { };
  49
  50  /// Gives the type of the ith element of a given tuple type.
  51  template<int __i, typename _Tp>
  52    struct tuple_element;
  53
  54  /// Finds the size of a given tuple type.
  55  template<typename _Tp>
  56    struct tuple_size;
  57
  58  // Adds a const reference to a non-reference type.
  59  template<typename _Tp>
  60    struct __add_c_ref
  61    { typedef const _Tp& type; };
  62
  63  template<typename _Tp>
  64    struct __add_c_ref<_Tp&>
  65    { typedef _Tp& type; };
  66
  67  // Adds a reference to a non-reference type.
  68  template<typename _Tp>
  69    struct __add_ref
  70    { typedef _Tp& type; };
  71
  72  template<typename _Tp>
  73    struct __add_ref<_Tp&>
  74    { typedef _Tp& type; };
  75
  76  // Class used in the implementation of get
  77  template<int __i, typename _Tp>
  78    struct __get_helper;
  79
  80  // Returns a const reference to the ith element of a tuple.
  81  // Any const or non-const ref elements are returned with their original type.
  82
  83  // This class helps construct the various comparison operations on tuples
  84  template<int __check_equal_size, int __i, int __j, typename _Tp, typename _Up>
  85    struct __tuple_compare;
  86
  87  // Helper which adds a reference to a type when given a reference_wrapper
  88  template<typename _Tp>
  89    struct __strip_reference_wrapper
  90    {
  91        typedef _Tp __type;
  92    };
  93
  94  template<typename _Tp>
  95    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
  96    {
  97      typedef _Tp& __type;
  98    };
  99
 100  template<typename _Tp>
 101    struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
 102    {
 103        typedef _Tp& __type;
 104    };
 105
 106   #include "tuple_defs.h"
 107
 108  template<int __i, int __j, typename _Tp, typename _Up>
 109    struct __tuple_compare<0, __i, __j, _Tp, _Up>
 110    {
 111      static bool __eq(const _Tp& __t, const _Up& __u)
 112      {
 113        return get<__i>(__t) == get<__i>(__u) &&
 114           __tuple_compare<0, __i+1, __j, _Tp, _Up>::__eq(__t, __u);
 115      }
 116      static bool __less(const _Tp& __t, const _Up& __u)
 117      {
 118        return (get<__i>(__t) < get<__i>(__u)) || !(get<__i>(__u) < get<__i>(__t)) &&
 119           __tuple_compare<0, __i+1, __j, _Tp, _Up>::__less(__t, __u);
 120      }
 121    };
 122
 123  template<int __i, typename _Tp, typename _Up>
 124    struct __tuple_compare<0, __i, __i, _Tp, _Up>
 125    {
 126      static bool __eq(const _Tp&, const _Up&)
 127      { return true; }
 128      static bool __less(const _Tp&, const _Up&)
 129      { return false; }
 130    };
 131
 132  // A class (and instance) which can be used in 'tie' when an element
 133  // of a tuple is not required
 134  struct swallow_assign
 135  {
 136    template<class T>
 137    swallow_assign&
 138      operator=(const T&)
 139      { return *this; }
 140  };
 141
 142  // TODO: Put this in some kind of shared file.
 143  namespace
 144  {
 145    swallow_assign ignore;
 146  }; // anonymous namespace
 147
 148 _GLIBCXX_END_NAMESPACE
 149 }
 150
 151 #define _GLIBCXX_CAT(x,y) _GLIBCXX_CAT2(x,y)
 152 #define _GLIBCXX_CAT2(x,y) x##y
 153 #define _SHORT_REPEAT
 154 #define _GLIBCXX_REPEAT_HEADER <tr1/tuple_iterate.h>
 155 #include <tr1/repeat.h>
 156 #undef _GLIBCXX_REPEAT_HEADER
 157 #undef _SHORT_REPEAT
 158
 159 #include <tr1/functional>
 160
 161 #endif