src/OpenFOAM/containers/Lists/CompactListList/CompactListList.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::CompactListList
  27
  28 Description
  29     A packed storage unstructured matrix of objects of type \<T\>
  30     using an offset table for access.
  31
  32     The offset table is the size of the number of rows whose elements are the
  33     accumulated sizes of the rows, i.e.
  34       - offset[i] gives the index of first element of row i + 1
  35       - offset[i] - offset[i-1] is the number of elements in row i
  36
  37     and for i = 0, offset[i-1] = 0.
  38
  39     Storage is allocated on free-store during construction.
  40
  41 SourceFiles
  42     CompactListList.C
  43     CompactListListI.H
  44     CompactListListIO.C
  45
  46 \*---------------------------------------------------------------------------*/
  47
  48 #ifndef CompactListList_H
  49 #define CompactListList_H
  50
  51 #include "labelList.H"
  52
  53 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  54
  55 namespace Foam
  56 {
  57
  58 // Forward declaration of friend functions and operators
  59
  60 template<class T> class CompactListList;
  61
  62 template<class T> Istream& operator>>(Istream&, CompactListList<T>&);
  63 template<class T> Ostream& operator<<(Ostream&, const CompactListList<T>&);
  64
  65
  66 /*---------------------------------------------------------------------------*\
  67                        Class CompactListList Declaration
  68 \*---------------------------------------------------------------------------*/
  69
  70 template<class T>
  71 class CompactListList
  72 {
  73     // Private data
  74
  75         //- Offset table
  76         List<label> offsets_;
  77
  78         //- Packed matrix of data
  79         List<T> m_;
  80
  81
  82 public:
  83
  84     // Static Member Functions
  85
  86         //- Return a null CompactListList
  87         inline static const CompactListList<T>& null();
  88
  89     // Constructors
  90
  91         //- Null constructor.
  92         inline CompactListList();
  93
  94         //- Construct by converting given List<List<T> >
  95         CompactListList(const List<List<T> >&);
  96
  97         //- Construct given size of offset table (number of rows)
  98         //  and number of data.
  99         inline CompactListList(const label nRows, const label nData);
 100
 101         //- Construct given size of offset table (number of rows),
 102         //  the number of data and a value for all elements.
 103         inline CompactListList(const label nRows, const label nData, const T&);
 104
 105         //- Construct given list of row-sizes.
 106         CompactListList(const UList<label>& rowSizes);
 107
 108         //- Construct given list of row-sizes
 109         CompactListList(const UList<label>& rowSizes, const T&);
 110
 111         //- Construct by transferring the parameter contents
 112         CompactListList(const Xfer<CompactListList<T> >&);
 113
 114         //- Construct as copy or re-use as specified.
 115         CompactListList(CompactListList<T>&, bool reUse);
 116
 117         //- Construct from Istream.
 118         CompactListList(Istream&);
 119
 120         //- Clone
 121         inline autoPtr<CompactListList<T> > clone() const;
 122
 123
 124     // Member Functions
 125
 126         // Access
 127
 128             //- Return the primary size, i.e. the number of rows
 129             inline label size() const;
 130
 131             //- Return true if the number of rows is zero
 132             inline bool empty() const;
 133
 134             //- Return the offset table
 135             inline const List<label>& offsets() const;
 136
 137             //- Return non-const access to the offset table
 138             inline List<label>& offsets();
 139
 140             //- Return the packed matrix of data
 141             inline const List<T>& m() const;
 142
 143             //- Return non-const access to the packed matrix of data
 144             inline List<T>& m();
 145
 146
 147         // Edit
 148
 149             //- Reset size of CompactListList.
 150             //  This form only allows contraction of the CompactListList.
 151             void setSize(const label nRows);
 152
 153             //- Reset size of CompactListList.
 154             void setSize(const label nRows, const label nData);
 155
 156             //- Reset sizes of CompactListList and value for new elements.
 157             void setSize(const label nRows, const label nData, const T&);
 158
 159             //- Reset size of CompactListList.
 160             void setSize(const UList<label>& rowSizes);
 161
 162             //- Reset size of CompactListList.
 163             //  This form only allows contraction of the CompactListList.
 164             inline void resize(const label nRows);
 165
 166             //- Reset size of CompactListList.
 167             inline void resize(const label nRows, const label nData);
 168
 169             //- Reset sizes of CompactListList and value for new elements.
 170             inline void resize(const label nRows, const label nData, const T&);
 171
 172             //- Reset size of CompactListList.
 173             inline void resize(const UList<label>& rowSizes);
 174
 175             //- Clear the CompactListList, i.e. set sizes to zero.
 176             void clear();
 177
 178             //- Return sizes (to be used e.g. for construction)
 179             labelList sizes() const;
 180
 181             //- Transfer the contents of the argument CompactListList
 182             //  into this CompactListList and annull the argument list.
 183             void transfer(CompactListList<T>&);
 184
 185             //- Transfer the contents to the Xfer container
 186             inline Xfer<CompactListList<T> > xfer();
 187
 188         // Other
 189
 190             //- Return index into m
 191             inline label index(const label row, const label col) const;
 192
 193             //- Get row for index into m.
 194             inline label whichRow(const label index) const;
 195
 196             //- Get column index (j) given above row
 197             inline label whichColumn(const label row, const label index) const;
 198
 199
 200     // Member operators
 201
 202         //- Return subscript-checked row as UList.
 203         inline UList<T> operator[](const label i);
 204
 205         //- Return const subscript-checked row as UList.
 206         inline const UList<T> operator[](const label i) const;
 207
 208         //- Return subscript-checked element.
 209         inline T& operator()(const label i, const label j);
 210
 211         //- Return const subscript-checked element.
 212         inline const T& operator()(const label i, const label j) const;
 213
 214         //- Return as List<List<T> >
 215         List<List<T> > operator()() const;
 216
 217         //- Assignment of all entries to the given value
 218         inline void operator=(const T&);
 219
 220
 221     // Istream operator
 222
 223         //- Read CompactListList from Istream, discarding contents
 224         //  of existing CompactListList.
 225         friend Istream& operator>> <T>(Istream&, CompactListList<T>&);
 226
 227         // Write CompactListList to Ostream.
 228         friend Ostream& operator<< <T>(Ostream&, const CompactListList<T>&);
 229 };
 230
 231
 232 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 233
 234 } // End namespace Foam
 235
 236 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 237
 238 #   include "CompactListListI.H"
 239
 240 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 241
 242 #ifdef NoRepository
 243 #   include "CompactListList.C"
 244 #endif
 245
 246 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 247
 248 #endif
 249
 250 // ************************************************************************* //