src/OpenFOAM/primitives/Tuple2/Tuple2.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::Tuple2
  27
  28 Description
  29     A 2-tuple.
  30
  31 SeeAlso
  32     Foam::Pair for storing two objects of identical types.
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef Tuple2_H
  37 #define Tuple2_H
  38
  39 #include "Istream.H"
  40
  41 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  42
  43 namespace Foam
  44 {
  45
  46 // Forward declaration of friend functions and operators
  47
  48 template<class Type1, class Type2>
  49 class Tuple2;
  50
  51 template<class Type1, class Type2>
  52 inline bool operator==
  53 (
  54     const Tuple2<Type1, Type2>&,
  55     const Tuple2<Type1, Type2>&
  56 );
  57
  58 template<class Type1, class Type2>
  59 inline bool operator!=
  60 (
  61     const Tuple2<Type1, Type2>&,
  62     const Tuple2<Type1, Type2>&
  63 );
  64
  65 template<class Type1, class Type2>
  66 inline Istream& operator>>(Istream&, Tuple2<Type1, Type2>&);
  67
  68 template<class Type1, class Type2>
  69 inline Ostream& operator<<(Ostream&, const Tuple2<Type1, Type2>&);
  70
  71
  72 /*---------------------------------------------------------------------------*\
  73                            class Tuple2 Declaration
  74 \*---------------------------------------------------------------------------*/
  75
  76 template<class Type1, class Type2>
  77 class Tuple2
  78 {
  79     // Private data
  80
  81         Type1 f_;
  82         Type2 s_;
  83
  84
  85 public:
  86
  87     // Constructors
  88
  89         //- Null constructor for lists
  90         inline Tuple2()
  91         {}
  92
  93         //- Construct from components
  94         inline Tuple2(const Type1& f, const Type2& s)
  95         :
  96             f_(f),
  97             s_(s)
  98         {}
  99
 100         //- Construct from Istream
 101         inline Tuple2(Istream& is)
 102         {
 103             is >> *this;
 104         }
 105
 106
 107     // Member Functions
 108
 109         //- Return first
 110         inline const Type1& first() const
 111         {
 112             return f_;
 113         }
 114
 115         //- Return first
 116         inline Type1& first()
 117         {
 118             return f_;
 119         }
 120
 121         //- Return second
 122         inline const Type2& second() const
 123         {
 124             return s_;
 125         }
 126
 127         //- Return second
 128         inline Type2& second()
 129         {
 130             return s_;
 131         }
 132
 133         //- Return reverse pair
 134         inline Tuple2<Type2, Type1> reverseTuple2() const
 135         {
 136             return Tuple2<Type2, Type1>(second(), first());
 137         }
 138
 139
 140     // Friend Operators
 141
 142         friend bool operator== <Type1, Type2>
 143         (
 144             const Tuple2<Type1, Type2>& a,
 145             const Tuple2<Type1, Type2>& b
 146         );
 147
 148         friend bool operator!= <Type1, Type2>
 149         (
 150             const Tuple2<Type1, Type2>& a,
 151             const Tuple2<Type1, Type2>& b
 152         );
 153
 154
 155     // IOstream operators
 156
 157         //- Read Tuple2 from Istream, discarding contents of existing Tuple2.
 158         friend Istream& operator>> <Type1, Type2>
 159         (
 160             Istream& is,
 161             Tuple2<Type1, Type2>& t2
 162         );
 163
 164         // Write Tuple2 to Ostream.
 165         friend Ostream& operator<< <Type1, Type2>
 166         (
 167             Ostream& os,
 168             const Tuple2<Type1, Type2>& t2
 169         );
 170 };
 171
 172
 173 template<class Type1, class Type2>
 174 inline bool operator==
 175 (
 176     const Tuple2<Type1, Type2>& a,
 177     const Tuple2<Type1, Type2>& b
 178 )
 179 {
 180     return
 181     (
 182         (a.first() == b.first()) && (a.second() == b.second())
 183     );
 184 }
 185
 186
 187 template<class Type1, class Type2>
 188 inline bool operator!=
 189 (
 190     const Tuple2<Type1, Type2>& a,
 191     const Tuple2<Type1, Type2>& b
 192 )
 193 {
 194     return !(a == b);
 195 }
 196
 197
 198 template<class Type1, class Type2>
 199 inline Istream& operator>>(Istream& is, Tuple2<Type1, Type2>& t2)
 200 {
 201     is.readBegin("Tuple2");
 202     is >> t2.f_ >> t2.s_;
 203     is.readEnd("Tuple2");
 204
 205     // Check state of Istream
 206     is.check("operator>>(Istream&, Tuple2<Type1, Type2>&)");
 207
 208     return is;
 209 }
 210
 211
 212 template<class Type1, class Type2>
 213 inline Ostream& operator<<(Ostream& os, const Tuple2<Type1, Type2>& t2)
 214 {
 215     os  << token::BEGIN_LIST
 216         << t2.f_ << token::SPACE << t2.s_
 217         << token::END_LIST;
 218
 219     return os;
 220 }
 221
 222
 223 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 224
 225 } // End namespace Foam
 226
 227 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 228
 229 #endif
 230
 231 // ************************************************************************* //