BiIndirectList.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
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
13  the Free Software Foundation, either version 3 of the License, or
14  (at your 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, see <http://www.gnu.org/licenses/>.
23 
24 Class
25  Foam::BiIndirectList
26 
27 Description
28  Indexes into negList (negative index) or posList (zero or positive index).
29 
30 SourceFiles
31  BiIndirectListI.H
32 
33 \*---------------------------------------------------------------------------*/
34 
35 #ifndef BiIndirectList_H
36 #define BiIndirectList_H
37 
38 #include "List.H"
39 
40 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
41 
42 namespace Foam
43 {
44 
45 /*---------------------------------------------------------------------------*\
46  Class BiIndirectList Declaration
47 \*---------------------------------------------------------------------------*/
48 
49 template<class T>
50 class BiIndirectList
51 {
52  // Private Data
53 
54  UList<T>& posList_;
55  UList<T>& negList_;
56  List<label> addressing_;
57 
58 
59 public:
60 
61  // Constructors
62 
63  //- Construct given the complete lists and the addressing array
64  inline BiIndirectList
65  (
66  const UList<T>& posList,
67  const UList<T>& negList,
68  const labelUList&
69  );
70 
71  //- Move constructor given the complete list and by moving addressing
72  inline BiIndirectList
73  (
74  const UList<T>& posList,
75  const UList<T>& negList,
76  List<label>&&
77  );
78 
79 
80  // Member Functions
81 
82  // Access
83 
84  //- Return the number of elements in the list
85  inline label size() const;
86 
87  //- Return true if the list is empty (ie, size() is zero).
88  inline bool empty() const;
89 
90  inline const UList<T>& posList() const;
91  inline const UList<T>& negList() const;
92 
93  //- Return the list addressing
94  inline const List<label>& addressing() const;
95 
96  //- Calculate index given whether index is into posList or negList
97  inline static label posIndex(const label);
98  inline static label negIndex(const label);
99 
100 
101  // Edit
102 
103  //- Reset addressing
104  inline void resetAddressing(const labelUList&);
105 
106 
107  // Member Operators
108 
109  //- Return the addressed elements as a List
110  inline List<T> operator()() const;
111 
112  //- Return non-const access to an element
113  inline T& operator[](const label);
114 
115  //- Return const access to an element
116  inline const T& operator[](const label) const;
117 
118  //- Move assignment to List of addressed elements
119  inline void operator=(List<T>&&);
120 
121  //- Assignment to UList of addressed elements
122  inline void operator=(const UList<T>&);
123 
124  //- Assignment of all entries to the given value
125  inline void operator=(const T&);
126 };
127 
128 
129 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
130 
131 } // End namespace Foam
132 
133 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
134 
135 #include "BiIndirectListI.H"
136 
137 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
138 
139 #endif
140 
141 // ************************************************************************* //
label size() const
Return the number of elements in the list.
BiIndirectList(const UList< T > &posList, const UList< T > &negList, const labelUList &)
Construct given the complete lists and the addressing array.
static label negIndex(const label)
T & operator[](const label)
Return non-const access to an element.
static label posIndex(const label)
Calculate index given whether index is into posList or negList.
bool empty() const
Return true if the list is empty (ie, size() is zero).
void operator=(List< T > &&)
Move assignment to List of addressed elements.
void resetAddressing(const labelUList &)
Reset addressing.
List< T > operator()() const
Return the addressed elements as a List.
A 1D vector of objects of type <T>, where the size of the vector is known and can be used for subscri...
Definition: HashTable.H:60
const UList< T > & negList() const
const UList< T > & posList() const
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
Indexes into negList (negative index) or posList (zero or positive index).
const List< label > & addressing() const
Return the list addressing.
Namespace for OpenFOAM.