src/OpenFOAM/containers/Lists/UPtrList/UPtrList.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::UPtrList
  27
  28 Description
  29     A 1D array of pointers to objects of type \<T\>, where the size of the
  30     array is known and used for subscript bounds checking, etc.
  31
  32     The element operator [] returns a reference to the object rather than a
  33     pointer.  Storage is not allocated during construction or use but is
  34     supplied to the constructor as an argument.
  35
  36 SourceFiles
  37     UPtrList.C
  38     UPtrListIO.C
  39
  40 \*---------------------------------------------------------------------------*/
  41
  42 #ifndef UPtrList_H
  43 #define UPtrList_H
  44
  45 #include "List.H"
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48
  49 namespace Foam
  50 {
  51
  52 // Forward declaration of friend functions and operators
  53
  54 template<class T> class UPtrList;
  55
  56 template<class T>
  57 inline typename UPtrList<T>::iterator operator+
  58 (
  59     const typename UPtrList<T>::iterator&,
  60     label
  61 );
  62
  63 template<class T>
  64 inline typename UPtrList<T>::iterator operator+
  65 (
  66     label,
  67     const typename UPtrList<T>::iterator&
  68 );
  69
  70 template<class T>
  71 inline typename UPtrList<T>::iterator operator-
  72 (
  73     const typename UPtrList<T>::iterator&,
  74     label
  75 );
  76
  77 template<class T>
  78 inline label operator-
  79 (
  80     const typename UPtrList<T>::iterator&,
  81     const typename UPtrList<T>::iterator&
  82 );
  83
  84 template<class T>
  85 Istream& operator>>(Istream&, UPtrList<T>&);
  86
  87 template<class T>
  88 Ostream& operator<<(Ostream&, const UPtrList<T>&);
  89
  90
  91 /*---------------------------------------------------------------------------*\
  92                            Class UPtrList Declaration
  93 \*---------------------------------------------------------------------------*/
  94
  95 template<class T>
  96 class UPtrList
  97 {
  98     // Private data
  99
 100         List<T*> ptrs_;
 101
 102
 103 public:
 104
 105     // Constructors
 106
 107         //- Null Constructor.
 108         UPtrList();
 109
 110         //- Construct with length specified.
 111         explicit UPtrList(const label);
 112
 113         //- Construct by transferring the parameter contents
 114         UPtrList(const Xfer<UPtrList<T> >&);
 115
 116         //- Construct as copy or re-use as specified.
 117         UPtrList(UPtrList<T>&, bool reUse);
 118
 119
 120     // Member functions
 121
 122         // Access
 123
 124             //- Return the number of elements in the UPtrList
 125             inline label size() const;
 126
 127             //- Return true if the UPtrList is empty (ie, size() is zero).
 128             inline bool empty() const;
 129
 130
 131         // Edit
 132
 133             //- Reset size of UPtrList.  This can only be used to set the size
 134             //  of an empty UPtrList, extend a UPtrList, remove entries from
 135             //  the end of a UPtrList.
 136             void setSize(const label);
 137
 138             //- Reset size of UPtrList.  This can only be used to set the size
 139             //  of an empty UPtrList, extend a UPtrList, remove entries from
 140             //  the end of a UPtrList.
 141             inline void resize(const label);
 142
 143             //- Clear the UPtrList, i.e. set size to zero
 144             void clear();
 145
 146             //- Transfer the contents of the argument UPtrList into this
 147             //  UPtrList and annull the argument list.
 148             void transfer(UPtrList<T>&);
 149
 150             //- Transfer contents to the Xfer container
 151             inline Xfer<UPtrList<T> > xfer();
 152
 153             //- Is element set
 154             inline bool set(const label) const;
 155
 156             //- Set element. Return old element (can be NULL).
 157             //  No checks on new element.
 158             inline T* set(const label, T*);
 159
 160             //- Reorders elements. Ordering does not have to be done in
 161             //  ascending or descending order. Reordering has to be unique.
 162             //  (is shuffle)
 163             void reorder(const UList<label>&);
 164
 165
 166     // Member operators
 167
 168         //- Return element const reference.
 169         inline const T& operator[](const label) const;
 170
 171         //- Return element reference.
 172         inline T& operator[](const label);
 173
 174         //- Return element const pointer.
 175         inline const T* operator()(const label) const;
 176
 177
 178     // STL type definitions
 179
 180         //- Type of values the UPtrList contains.
 181         typedef T value_type;
 182
 183         //- Type that can be used for storing into UPtrList::value_type objects.
 184         typedef T& reference;
 185
 186         //- Type that can be used for storing into constant UPtrList::value_type
 187         //  objects.
 188         typedef const T& const_reference;
 189
 190
 191     // STL iterator
 192     // Random access iterator for traversing UPtrList.
 193
 194         class iterator;
 195         friend class iterator;
 196
 197         //- An STL iterator
 198         class iterator
 199         {
 200             T** ptr_;
 201
 202         public:
 203
 204             //- Construct for a given UPtrList entry
 205             inline iterator(T**);
 206
 207             // Member operators
 208
 209                 inline bool operator==(const iterator&) const;
 210                 inline bool operator!=(const iterator&) const;
 211
 212                 inline T& operator*();
 213                 inline T& operator()();
 214
 215                 inline iterator operator++();
 216                 inline iterator operator++(int);
 217
 218                 inline iterator operator--();
 219                 inline iterator operator--(int);
 220
 221                 inline iterator operator+=(label);
 222
 223                 friend iterator operator+ <T>(const iterator&, label);
 224                 friend iterator operator+ <T>(label, const iterator&);
 225
 226                 inline iterator operator-=(label);
 227
 228                 friend iterator operator- <T>(const iterator&, label);
 229
 230                 friend label operator- <T>
 231                 (
 232                     const iterator&,
 233                     const iterator&
 234                 );
 235
 236                 inline T& operator[](label);
 237
 238                 inline bool operator<(const iterator&) const;
 239                 inline bool operator>(const iterator&) const;
 240
 241                 inline bool operator<=(const iterator&) const;
 242                 inline bool operator>=(const iterator&) const;
 243         };
 244
 245         //- Return an iterator to begin traversing the UPtrList.
 246         inline iterator begin();
 247
 248         //- Return an iterator to end traversing the UPtrList.
 249         inline iterator end();
 250
 251
 252     // IOstream operator
 253
 254         // Write List to Ostream.
 255         friend Ostream& operator<< <T>(Ostream&, const UPtrList<T>&);
 256 };
 257
 258
 259 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 260
 261 } // End namespace Foam
 262
 263 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 264
 265 #   include "UPtrListI.H"
 266
 267 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 268
 269 #ifdef NoRepository
 270 #   include "UPtrList.C"
 271 #endif
 272
 273 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 274
 275 #endif
 276
 277 // ************************************************************************* //