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
|
/*=========================================================================
Program: Visualization Toolkit
Module: vtkIdList.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
/**
* @class vtkIdList
* @brief list of point or cell ids
*
* vtkIdList is used to represent and pass data id's between
* objects. vtkIdList may represent any type of integer id, but
* usually represents point and cell ids.
*/
#ifndef vtkIdList_h
#define vtkIdList_h
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkObject.h"
class VTKCOMMONCORE_EXPORT vtkIdList : public vtkObject
{
public:
static vtkIdList *New();
void Initialize();
/**
* Allocate a capacity for sz ids in the list and
* set the number of stored ids in the list to 0.
* strategy is not used.
*/
int Allocate(const vtkIdType sz, const int strategy=0);
vtkTypeMacro(vtkIdList,vtkObject);
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
/**
* Return the number of id's in the list.
*/
vtkIdType GetNumberOfIds() {return this->NumberOfIds;};
/**
* Return the id at location i.
*/
vtkIdType GetId(const vtkIdType i) {return this->Ids[i];};
/**
* Specify the number of ids for this object to hold. Does an
* allocation as well as setting the number of ids.
*/
void SetNumberOfIds(const vtkIdType number);
/**
* Set the id at location i. Doesn't do range checking so it's a bit
* faster than InsertId. Make sure you use SetNumberOfIds() to allocate
* memory prior to using SetId().
*/
void SetId(const vtkIdType i, const vtkIdType vtkid) {this->Ids[i] = vtkid;};
/**
* Set the id at location i. Does range checking and allocates memory
* as necessary.
*/
void InsertId(const vtkIdType i, const vtkIdType vtkid);
/**
* Add the id specified to the end of the list. Range checking is performed.
*/
vtkIdType InsertNextId(const vtkIdType vtkid);
/**
* If id is not already in list, insert it and return location in
* list. Otherwise return just location in list.
*/
vtkIdType InsertUniqueId(const vtkIdType vtkid);
/**
* Get a pointer to a particular data index.
*/
vtkIdType *GetPointer(const vtkIdType i) {return this->Ids + i;};
/**
* Get a pointer to a particular data index. Make sure data is allocated
* for the number of items requested. Set MaxId according to the number of
* data values requested.
*/
vtkIdType *WritePointer(const vtkIdType i, const vtkIdType number);
/**
* Specify an array of vtkIdType to use as the id list. This replaces the
* underlying array. This instance of vtkIdList takes ownership of the
* array, meaning that it deletes it on destruction (using delete[]).
*/
void SetArray(vtkIdType *array, vtkIdType size);
/**
* Reset to an empty state.
*/
void Reset() {this->NumberOfIds = 0;};
/**
* Free any unused memory.
*/
void Squeeze() {this->Resize(this->NumberOfIds);};
/**
* Copy an id list by explicitly copying the internal array.
*/
void DeepCopy(vtkIdList *ids);
/**
* Delete specified id from list. Will remove all occurrences of id in list.
*/
void DeleteId(vtkIdType vtkid);
/**
* Return -1 if id specified is not contained in the list; otherwise return
* the position in the list.
*/
vtkIdType IsId(vtkIdType vtkid);
/**
* Intersect this list with another vtkIdList. Updates current list according
* to result of intersection operation.
*/
void IntersectWith(vtkIdList* otherIds);
/**
* Adjust the size of the id list while maintaining its content (except
* when being truncated).
*/
vtkIdType *Resize(const vtkIdType sz);
// This method should become legacy
void IntersectWith(vtkIdList& otherIds) {
this->IntersectWith(&otherIds); };
protected:
vtkIdList();
~vtkIdList() VTK_OVERRIDE;
vtkIdType NumberOfIds;
vtkIdType Size;
vtkIdType *Ids;
private:
vtkIdList(const vtkIdList&) VTK_DELETE_FUNCTION;
void operator=(const vtkIdList&) VTK_DELETE_FUNCTION;
};
// In-lined for performance
inline void vtkIdList::InsertId(const vtkIdType i, const vtkIdType vtkid)
{
if (i >= this->Size)
{
this->Resize(i + 1);
}
this->Ids[i] = vtkid;
if (i >= this->NumberOfIds)
{
this->NumberOfIds = i + 1;
}
}
// In-lined for performance
inline vtkIdType vtkIdList::InsertNextId(const vtkIdType vtkid)
{
if ( this->NumberOfIds >= this->Size )
{
if (!this->Resize(2*this->NumberOfIds+1)) //grow by factor of 2
{
return this->NumberOfIds-1;
}
}
this->Ids[this->NumberOfIds++] = vtkid;
return this->NumberOfIds-1;
}
inline vtkIdType vtkIdList::IsId(vtkIdType vtkid)
{
vtkIdType *ptr, i;
for (ptr=this->Ids, i=0; i<this->NumberOfIds; i++, ptr++)
{
if ( vtkid == *ptr )
{
return i;
}
}
return (-1);
}
#endif
|
