src/OpenFOAM/containers/Lists/FixedList/FixedList.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::FixedList
  27
  28 Description
  29     A 1D vector of objects of type \<T\> with a fixed size \<Size\>.
  30
  31 SourceFiles
  32     FixedList.C
  33     FixedListI.H
  34     FixedListIO.C
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #ifndef FixedList_H
  39 #define FixedList_H
  40
  41 #include "bool.H"
  42 #include "label.H"
  43 #include "uLabel.H"
  44 #include "Hash.H"
  45 #include "autoPtr.H"
  46 #include "StaticAssert.H"
  47
  48 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  49
  50 namespace Foam
  51 {
  52
  53 // Forward declaration of friend functions and operators
  54
  55 template<class T, unsigned Size> class FixedList;
  56
  57 template<class T, unsigned Size>
  58 Istream& operator>>(Istream&, FixedList<T, Size>&);
  59
  60 template<class T, unsigned Size>
  61 Ostream& operator<<(Ostream&, const FixedList<T, Size>&);
  62
  63 template<class T> class UList;
  64 template<class T> class SLList;
  65
  66
  67 /*---------------------------------------------------------------------------*\
  68                            Class FixedList Declaration
  69 \*---------------------------------------------------------------------------*/
  70
  71 template<class T, unsigned Size>
  72 class FixedList
  73 {
  74 #ifndef SWIG
  75     //- Size must be positive (non-zero) and also fit as a signed value
  76     StaticAssert(Size && Size <= INT_MAX);
  77 #endif
  78
  79
  80     // Private data
  81
  82         //- Vector of values of type T of size Size.
  83         T v_[Size];
  84
  85
  86 public:
  87
  88     //- Hashing function class.
  89     //  Use Hasher directly for contiguous data. Otherwise hash incrementally.
  90     template< class HashT=Hash<T> >
  91     class Hash
  92     {
  93     public:
  94
  95         Hash()
  96         {}
  97
  98         inline unsigned operator()
  99         (
 100             const FixedList<T, Size>&,
 101             unsigned seed = 0
 102         ) const;
 103     };
 104
 105     // Static Member Functions
 106
 107         //- Return a null FixedList
 108         inline static const FixedList<T, Size>& null();
 109
 110
 111     // Constructors
 112
 113         //- Null constructor.
 114         inline FixedList();
 115
 116         //- Construct from components
 117         inline FixedList(const T v[Size]);
 118
 119         //- Construct from value
 120         explicit inline FixedList(const T&);
 121
 122         //- Construct from UList.
 123         inline FixedList(const UList<T>&);
 124
 125         //- Construct from SLList.
 126         inline FixedList(const SLList<T>&);
 127
 128         //- Copy constructor.
 129         inline FixedList(const FixedList<T, Size>&);
 130
 131         //- Construct from Istream.
 132         FixedList(Istream&);
 133
 134         //- Clone
 135         inline autoPtr< FixedList<T, Size> > clone() const;
 136
 137
 138     // Member Functions
 139
 140         // Access
 141
 142             //- Return the forward circular index, i.e. the next index
 143             //  which returns to the first at the end of the list
 144             inline label fcIndex(const label i) const;
 145
 146             //- Return the reverse circular index, i.e. the previous index
 147             //  which returns to the last at the beginning of the list
 148             inline label rcIndex(const label i) const;
 149
 150
 151             //- Return a const pointer to the first data element,
 152             //  similar to the STL front() method and the string::data() method
 153             //  This can be used (with caution) when interfacing with C code.
 154             inline const T* cdata() const;
 155
 156             //- Return a pointer to the first data element,
 157             //  similar to the STL front() method and the string::data() method
 158             //  This can be used (with caution) when interfacing with C code.
 159             inline T* data();
 160
 161
 162         // Check
 163
 164             //- Check start is within valid range (0 ... size-1).
 165             inline void checkStart(const label start) const;
 166
 167             //- Check size is within valid range (0 ... size).
 168             inline void checkSize(const label size) const;
 169
 170             //- Check index i is within valid range (0 ... size-1).
 171             inline void checkIndex(const label i) const;
 172
 173
 174         // Edit
 175
 176             //- Dummy resize function
 177             //  needed to make FixedList consistent with List
 178             inline void resize(const label);
 179
 180             //- Dummy setSize function
 181             //  needed to make FixedList consistent with List
 182             inline void setSize(const label);
 183
 184             //- Copy (not transfer) the argument contents
 185             //  needed to make FixedList consistent with List
 186             void transfer(const FixedList<T, Size>&);
 187
 188         //- Write the FixedList as a dictionary entry
 189         void writeEntry(Ostream&) const;
 190
 191         //- Write the FixedList as a dictionary entry with keyword
 192         void writeEntry(const word& keyword, Ostream&) const;
 193
 194
 195     // Member operators
 196
 197         //- Return element of FixedList.
 198         inline T& operator[](const label);
 199
 200         //- Return element of constant FixedList.
 201         inline const T& operator[](const label) const;
 202
 203         //- Assignment from array operator. Takes linear time.
 204         inline void operator=(const T v[Size]);
 205
 206         //- Assignment from UList operator. Takes linear time.
 207         inline void operator=(const UList<T>&);
 208
 209         //- Assignment from SLList operator. Takes linear time.
 210         inline void operator=(const SLList<T>&);
 211
 212         //- Assignment of all entries to the given value
 213         inline void operator=(const T&);
 214
 215
 216     // STL type definitions
 217
 218         //- Type of values the FixedList contains.
 219         typedef T value_type;
 220
 221         //- Type that can be used for storing into
 222         //  FixedList::value_type objects.
 223         typedef T& reference;
 224
 225         //- Type that can be used for storing into
 226         //  constant FixedList::value_type objects
 227         typedef const T& const_reference;
 228
 229         //- The type that can represent the difference between any two
 230         //  FixedList iterator objects.
 231         typedef label difference_type;
 232
 233         //- The type that can represent the size of a FixedList.
 234         typedef label size_type;
 235
 236
 237     // STL iterator
 238
 239         //- Random access iterator for traversing FixedList.
 240         typedef T* iterator;
 241
 242         //- Return an iterator to begin traversing the FixedList.
 243         inline iterator begin();
 244
 245         //- Return an iterator to end traversing the FixedList.
 246         inline iterator end();
 247
 248
 249     // STL const_iterator
 250
 251         //- Random access iterator for traversing FixedList.
 252         typedef const T* const_iterator;
 253
 254         //- Return const_iterator to begin traversing the constant FixedList.
 255         inline const_iterator cbegin() const;
 256
 257         //- Return const_iterator to end traversing the constant FixedList.
 258         inline const_iterator cend() const;
 259
 260         //- Return const_iterator to begin traversing the constant FixedList.
 261         inline const_iterator begin() const;
 262
 263         //- Return const_iterator to end traversing the constant FixedList.
 264         inline const_iterator end() const;
 265
 266
 267     // STL reverse_iterator
 268
 269         //- Reverse iterator for reverse traversal of FixedList.
 270         typedef T* reverse_iterator;
 271
 272         //- Return reverse_iterator to begin reverse traversing the FixedList.
 273         inline reverse_iterator rbegin();
 274
 275         //- Return reverse_iterator to end reverse traversing the FixedList.
 276         inline reverse_iterator rend();
 277
 278
 279     // STL const_reverse_iterator
 280
 281         //- Reverse iterator for reverse traversal of constant FixedList.
 282         typedef const T* const_reverse_iterator;
 283
 284         //- Return const_reverse_iterator to begin reverse traversing FixedList.
 285         inline const_reverse_iterator crbegin() const;
 286
 287         //- Return const_reverse_iterator to end reverse traversing FixedList.
 288         inline const_reverse_iterator crend() const;
 289
 290         //- Return const_reverse_iterator to begin reverse traversing FixedList.
 291         inline const_reverse_iterator rbegin() const;
 292
 293         //- Return const_reverse_iterator to end reverse traversing FixedList.
 294         inline const_reverse_iterator rend() const;
 295
 296
 297     // STL member functions
 298
 299         //- Return the number of elements in the FixedList.
 300         inline label size() const;
 301
 302         //- Return size of the largest possible FixedList.
 303         inline label max_size() const;
 304
 305         //- Return true if the FixedList is empty (ie, size() is zero).
 306         inline bool empty() const;
 307
 308         //- Swap two FixedLists of the same type in constant time.
 309         void swap(FixedList<T, Size>&);
 310
 311
 312     // STL member operators
 313
 314         //- Equality operation on FixedLists of the same type.
 315         //  Returns true when the FixedLists are elementwise equal
 316         //  (using FixedList::value_type::operator==).  Takes linear time.
 317         bool operator==(const FixedList<T, Size>&) const;
 318
 319         //- The opposite of the equality operation. Takes linear time.
 320         bool operator!=(const FixedList<T, Size>&) const;
 321
 322         //- Compare two FixedLists lexicographically. Takes linear time.
 323         bool operator<(const FixedList<T, Size>&) const;
 324
 325         //- Compare two FixedLists lexicographically. Takes linear time.
 326         bool operator>(const FixedList<T, Size>&) const;
 327
 328         //- Return true if !(a > b). Takes linear time.
 329         bool operator<=(const FixedList<T, Size>&) const;
 330
 331         //- Return true if !(a < b). Takes linear time.
 332         bool operator>=(const FixedList<T, Size>&) const;
 333
 334
 335     // IOstream operators
 336
 337         //- Read List from Istream, discarding contents of existing List.
 338
 339 #ifndef SWIG
 340         friend Istream& operator>> <T, Size>
 341         (Istream&, FixedList<T, Size>&);
 342
 343         // Write FixedList to Ostream.
 344         friend Ostream& operator<< <T, Size>
 345         (
 346             Ostream&,
 347             const FixedList<T, Size>&
 348         );
 349 #endif
 350 };
 351
 352
 353 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 354
 355 } // End namespace Foam
 356
 357 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 358
 359 #include "FixedListI.H"
 360
 361 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 362
 363 #ifdef NoRepository
 364 #   include "FixedList.C"
 365 #endif
 366
 367 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 368
 369 #endif
 370
 371 // ************************************************************************* //