src/OpenFOAM/primitives/Tuple2/Tuple2.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   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 (a.first() == b.first() && a.second() == b.second());
 181 }
 182
 183
 184 template<class Type1, class Type2>
 185 inline bool operator!=
 186 (
 187     const Tuple2<Type1, Type2>& a,
 188     const Tuple2<Type1, Type2>& b
 189 )
 190 {
 191     return !(a == b);
 192 }
 193
 194
 195 template<class Type1, class Type2>
 196 inline Istream& operator>>(Istream& is, Tuple2<Type1, Type2>& t2)
 197 {
 198     is.readBegin("Tuple2");
 199     is >> t2.f_ >> t2.s_;
 200     is.readEnd("Tuple2");
 201
 202     // Check state of Istream
 203     is.check("operator>>(Istream&, Tuple2<Type1, Type2>&)");
 204
 205     return is;
 206 }
 207
 208
 209 template<class Type1, class Type2>
 210 inline Ostream& operator<<(Ostream& os, const Tuple2<Type1, Type2>& t2)
 211 {
 212     os  << token::BEGIN_LIST
 213         << t2.f_ << token::SPACE << t2.s_
 214         << token::END_LIST;
 215
 216     return os;
 217 }
 218
 219
 220 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 221
 222 } // End namespace Foam
 223
 224 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 225
 226 #endif
 227
 228 // ************************************************************************* //