src/meshLibrary/utilities/containers/LongList/LongList.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | cfMesh: A library for mesh generation
   4    \\    /   O peration     |
   5     \\  /    A nd           | Author: Franjo Juretic (franjo.juretic@c-fields.com)
   6      \\/     M anipulation  | Copyright (C) Creative Fields, Ltd.
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of cfMesh.
  10
  11     cfMesh 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     cfMesh 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 cfMesh.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     LongList
  26
  27 Description
  28     A dynamic list is a 1-D vector of objects of type T which resizes
  29     itself as necessary to accept the new objects.  Internal storage
  30     is a 2-D graph with a fixed size of the chunks used to store the data.
  31     This way the data does not get copied every time array is resized, but
  32     only the pointers to the chunks of data.
  33
  34 SourceFiles
  35     LongListI.H
  36     LongList.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef LongList_H
  41 #define LongList_H
  42
  43 #include "label.H"
  44 #include "bool.H"
  45 #include "error.H"
  46
  47 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  48
  49 namespace Foam
  50 {
  51
  52 // * * * * * * Forward declaration of template friend fuctions * * * * * * * //
  53
  54 template<class T, label Offset>
  55 class LongList;
  56
  57 template<class T, label Offset>
  58 Ostream& operator<<
  59 (
  60     Ostream&,
  61     const LongList<T, Offset>&
  62 );
  63 template<class T, label Offset>
  64 Istream& operator>>
  65 (
  66     Istream&,
  67     LongList<T, Offset>&
  68 );
  69
  70 /*---------------------------------------------------------------------------*\
  71                            Class LongList Declaration
  72 \*---------------------------------------------------------------------------*/
  73
  74 template<class T, label Offset = 19>
  75 class LongList
  76 {
  77     // Private data
  78         //- number of allocated elements
  79         label N_;
  80
  81         //- number of elements in the list
  82         label nextFree_;
  83
  84         //- number of used blocks of data
  85         label numBlocks_;
  86
  87         //- maximum number of blocks that can be allocated
  88         //- without reallocating the list containing pointers
  89         //- to the chunks of data
  90         label numAllocatedBlocks_;
  91
  92         //- size of blocks is calculated by powers of 2
  93         //- and therefore the access can be done using shift and mask
  94         label shift_;
  95         label mask_;
  96
  97         //- array of pointers to the blocks of data, each of the size WIDTH
  98         T** dataPtr_;
  99
 100     // Private member functions
 101         //- check index
 102         void checkIndex(label const i) const;
 103
 104         //- initialize width and mask
 105         void initializeParameters();
 106
 107         //- Allocate memory for the list
 108         void allocateSize(const label);
 109
 110         //- delete all elements
 111         void clearOut();
 112
 113 public:
 114
 115     // Constructors
 116
 117         //- Construct null
 118         inline LongList();
 119
 120         //- Construct given size
 121         explicit inline LongList(const label size);
 122
 123         //- Construct to given size and initialize
 124         explicit inline LongList(const label size, const T& t);
 125
 126         //- Copy contructor
 127         inline LongList(const LongList<T, Offset>&);
 128
 129     // Destructor
 130
 131         inline ~LongList();
 132
 133     // Member Functions
 134
 135         // Access
 136
 137             //- Size of the active part of the list.
 138             inline label size() const;
 139
 140             //- Return the binary size in number of characters of the UList
 141             //  if the element is a primitive type
 142             //  i.e. contiguous<T>() == true
 143             inline label byteSize() const;
 144
 145         // Edit
 146
 147             //- Reset size of List.
 148             void setSize(const label);
 149
 150             //- Clear the list, i.e. set next free to zero.
 151             //  Allocated size does not change
 152             void clear();
 153
 154             //- Shrink the list to the number of elements used
 155             inline LongList<T, Offset>& shrink();
 156
 157             //- transfer the list from another one without allocating it
 158             inline void transfer(LongList<T, Offset>&);
 159
 160
 161     // Member Operators
 162
 163         //- Append an element at the end of the list
 164         inline void append(const T& e);
 165
 166         //- Append an element at the end of the list if it is not yet
 167         //- present in the list (takes linear time)
 168         inline void appendIfNotIn(const T& e);
 169
 170         //- check if the element is in the list (takes linear time)
 171         inline bool contains(const T& e) const;
 172         inline label containsAtPosition(const T& e) const;
 173
 174         //- Return and remove the element
 175         inline T remove(const label i);
 176         inline T removeLastElement();
 177
 178         //- get and set operators
 179         inline const T& operator[](const label i) const;
 180         inline T& operator[](const label i);
 181
 182         //- Return non-const access to an element,
 183         //  resizing the list if necessary
 184         inline T& operator()(const label);
 185
 186         //- return a non-const access to an element,
 187         // resize the list if necessary
 188         inline T& newElmt(const label);
 189
 190         //- Assignment of all entries to the given value
 191         inline void operator=(const T&);
 192
 193         //- Assignment operator
 194         inline void operator=(const LongList<T, Offset>&);
 195
 196
 197     // IOstream operators
 198         //- Read from stream and append to the current content
 199         void appendFromStream(Istream&);
 200
 201         //- Write as a dictionary entry.
 202         void writeEntry(Ostream& os) const;
 203
 204         //- Write as a dictionary entry with keyword.
 205         void writeEntry(const word& keyword, Ostream& os) const;
 206
 207         // Write LongList to Ostream.
 208         friend Ostream& operator<< <T, Offset>
 209         (
 210             Ostream&,
 211             const LongList<T, Offset>&
 212         );
 213
 214         //- Read from Istream, discarding contents of existing LongList.
 215         friend Istream& operator>> <T, Offset>
 216         (
 217             Istream&,
 218             LongList<T, Offset>&
 219         );
 220 };
 221
 222
 223 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 224
 225 } // End namespace Foam
 226
 227 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 228
 229 #include "LongListI.H"
 230
 231 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 232
 233 #ifdef NoRepository
 234 #   include "LongList.C"
 235 #endif
 236
 237 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 238
 239 #endif
 240
 241 // ************************************************************************* //