File: itkMapContainer.hxx

package info (click to toggle)
insighttoolkit5 5.4.3-5
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 704,384 kB
  • sloc: cpp: 783,592; ansic: 628,724; xml: 44,704; fortran: 34,250; python: 22,874; sh: 4,078; pascal: 2,636; lisp: 2,158; makefile: 464; yacc: 328; asm: 205; perl: 203; lex: 146; tcl: 132; javascript: 98; csh: 81
file content (251 lines) | stat: -rw-r--r-- 7,018 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkMapContainer_hxx
#define itkMapContainer_hxx

namespace itk
{
/**
 * Get a reference to the element at the given index.
 * If the index does not exist, it is created automatically.
 *
 * It is assumed that the value of the element is modified through the
 * reference.
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::ElementAt(ElementIdentifier id) -> Element &
{
  this->Modified();
  return this->MapType::operator[](id);
}

/**
 * Get a reference to the element at the given index.
 *
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::ElementAt(ElementIdentifier id) const -> const Element &
{
  return this->MapType::find(id)->second;
}

/**
 * Get a reference to the element at the given index.
 * If the index does not exist, it is created automatically.
 *
 * It is assumed that the value of the element is modified through the
 * reference.
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::CreateElementAt(ElementIdentifier id) -> Element &
{
  this->Modified();
  return this->MapType::operator[](id);
}

/**
 * Get the element at the specified index.  There is no check for
 * existence performed.
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::GetElement(ElementIdentifier id) const -> Element
{
  return this->MapType::find(id)->second;
}

/**
 * Set the given index value to the given element.  If the index doesn't
 * exist, it is automatically created.
 */
template <typename TElementIdentifier, typename TElement>
void
MapContainer<TElementIdentifier, TElement>::SetElement(ElementIdentifier id, Element element)
{
  MapType::operator[](id) = element;
  this->Modified();
}

/**
 * Set the given index value to the given element.  If the index doesn't
 * exist, it is automatically created.
 */
template <typename TElementIdentifier, typename TElement>
void
MapContainer<TElementIdentifier, TElement>::InsertElement(ElementIdentifier id, Element element)
{
  this->MapType::operator[](id) = element;
  this->Modified();
}

/**
 * Check if the STL map has an entry corresponding to the given index.
 * The count will be either 1 or 0.
 */
template <typename TElementIdentifier, typename TElement>
bool
MapContainer<TElementIdentifier, TElement>::IndexExists(ElementIdentifier id) const
{
  return (this->MapType::find(id) != this->MapType::end());
}

/**
 * If the given index doesn't exist in the map, return false.
 * Otherwise, set the element through the pointer (if it isn't null), and
 * return true.
 */
template <typename TElementIdentifier, typename TElement>
bool
MapContainer<TElementIdentifier, TElement>::GetElementIfIndexExists(ElementIdentifier id, Element * element) const
{
  auto it = this->MapType::find(id);
  if (it != this->MapType::end())
  {
    if (element)
    {
      *element = it->second;
    }
    return true;
  }
  return false;
}

/**
 * The STL map will create an entry for a given index through the indexing
 * operator.  Whether or not it is created, it will be assigned to the
 * default element.
 */
template <typename TElementIdentifier, typename TElement>
void
MapContainer<TElementIdentifier, TElement>::CreateIndex(ElementIdentifier id)
{
  this->MapType::operator[](id) = Element();
  this->Modified();
}

/**
 * Delete the entry in the STL map corresponding to the given identifier.
 * If the entry does not exist, nothing happens.
 */
template <typename TElementIdentifier, typename TElement>
void
MapContainer<TElementIdentifier, TElement>::DeleteIndex(ElementIdentifier id)
{
  this->MapType::erase(id);
  this->Modified();
}

/**
 * Get a begin const iterator for the map.
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::Begin() const -> ConstIterator
{
  return ConstIterator(this->MapType::begin());
}

/**
 * Get an end const iterator for the map.
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::End() const -> ConstIterator
{
  return ConstIterator(this->MapType::end());
}

/**
 * Get a begin const iterator for the map.
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::Begin() -> Iterator
{
  return Iterator(this->MapType::begin());
}

/**
 * Get an end const iterator for the map.
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::End() -> Iterator
{
  return Iterator(this->MapType::end());
}

/**
 * Get the number of elements currently stored in the map.
 */
template <typename TElementIdentifier, typename TElement>
auto
MapContainer<TElementIdentifier, TElement>::Size() const -> ElementIdentifier
{
  return static_cast<ElementIdentifier>(this->MapType::size());
}

/**
 * Tell the container to allocate enough memory to allow at least as many
 * elements as the size given to be stored.  This is NOT guaranteed to actually
 * allocate any memory, but is useful if the implementation of the container
 * allocates contiguous storage.
 *
 * \warning In the particular case of the MapContainer, this method only
 * allocates memory for one element, not for the ones with index between zero
 * and "size".
 */
template <typename TElementIdentifier, typename TElement>
void
MapContainer<TElementIdentifier, TElement>::Reserve(ElementIdentifier sz)
{
  ElementIdentifier curSize = this->Size();

  while (curSize < sz)
  {
    this->CreateIndex(curSize);
    curSize = this->Size();
  }
}

/**
 * Tell the container to try to minimize its memory usage for storage of
 * the current number of elements.  This is NOT guaranteed to decrease
 * memory usage.
 */
template <typename TElementIdentifier, typename TElement>
void
MapContainer<TElementIdentifier, TElement>::Squeeze()
{}

/**
 * Tell the container to release any memory it may have allocated and
 * return itself to its initial state.
 */
template <typename TElementIdentifier, typename TElement>
void
MapContainer<TElementIdentifier, TElement>::Initialize()
{
  this->MapType::clear();
}
} // end namespace itk

#endif