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