CoCalc -- GNEHierarchicalStructureParents.cpp

GitHub Repository: eclipse/sumo
Path: blob/main/src/netedit/elements/GNEHierarchicalStructureParents.cpp
¹⁶⁹⁶⁷⁸ views
1
/****************************************************************************/
2
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3
// Copyright (C) 2001-2025 German Aerospace Center (DLR) and others.
4
// This program and the accompanying materials are made available under the
5
// terms of the Eclipse Public License 2.0 which is available at
6
// https://www.eclipse.org/legal/epl-2.0/
7
// This Source Code may also be made available under the following Secondary
8
// Licenses when the conditions for such availability set forth in the Eclipse
9
// Public License 2.0 are satisfied: GNU General Public License, version 2
10
// or later which is available at
11
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13
/****************************************************************************/
14
/// @file    GNEHierarchicalStructureParents.cpp
15
/// @author  Pablo Alvarez Lopez
16
/// @date    Feb 2025
17
///
18
// Structure for GNEHierarchicalElements centered in parents
19
/****************************************************************************/
20

21
#include <netedit/elements/network/GNEJunction.h>
22
#include <netedit/elements/network/GNEEdge.h>
23
#include <netedit/elements/network/GNELane.h>
24
#include <netedit/elements/demand/GNEDemandElement.h>
25
#include <netedit/elements/additional/GNEAdditional.h>
26
#include <netedit/elements/additional/GNETAZSourceSink.h>
27
#include <netedit/elements/data/GNEGenericData.h>
28
#include <utils/common/UtilExceptions.h>
29

30
#include "GNEHierarchicalStructureParents.h"
31

32
// ===========================================================================
33
// member method definitions
34
// ===========================================================================
35

36
GNEHierarchicalStructureParents::GNEHierarchicalStructureParents() {}
37

38

39
void
40
GNEHierarchicalStructureParents::clear() {
41
    myParentJunctions.clear();
42
    myParentEdges.clear();
43
    myParentLanes.clear();
44
    myParentAdditionals.clear();
45
    myParentTAZSourceSinks.clear();
46
    myParentDemandElements.clear();
47
    myParentGenericDatas.clear();
48
}
49

50
// get functions
51

52
template<> const GNEHierarchicalContainerParents<GNEJunction*>&
53
GNEHierarchicalStructureParents::get() const {
54
    return myParentJunctions;
55
}
56

57

58
template<> const GNEHierarchicalContainerParents<GNEEdge*>&
59
GNEHierarchicalStructureParents::get() const {
60
    return myParentEdges;
61
}
62

63

64
template<> const GNEHierarchicalContainerParents<GNELane*>&
65
GNEHierarchicalStructureParents::get() const {
66
    return myParentLanes;
67
}
68

69

70
template<> const GNEHierarchicalContainerParents<GNEAdditional*>&
71
GNEHierarchicalStructureParents::get() const {
72
    return myParentAdditionals;
73
}
74

75

76
template<> const GNEHierarchicalContainerParents<GNETAZSourceSink*>&
77
GNEHierarchicalStructureParents::get() const {
78
    return myParentTAZSourceSinks;
79
}
80

81

82
template<> const GNEHierarchicalContainerParents<GNEDemandElement*>&
83
GNEHierarchicalStructureParents::get() const {
84
    return myParentDemandElements;
85
}
86

87

88
template<> const GNEHierarchicalContainerParents<GNEGenericData*>&
89
GNEHierarchicalStructureParents::get() const {
90
    return myParentGenericDatas;
91
}
92

93
// at functions
94

95
template<> GNEJunction*
96
GNEHierarchicalStructureParents::at(const int index) const {
97
    return myParentJunctions.at(index);
98
}
99

100

101
template<> GNEEdge*
102
GNEHierarchicalStructureParents::at(const int index) const {
103
    return myParentEdges.at(index);
104
}
105

106

107
template<> GNELane*
108
GNEHierarchicalStructureParents::at(const int index) const {
109
    return myParentLanes.at(index);
110
}
111

112

113
template<> GNEAdditional*
114
GNEHierarchicalStructureParents::at(const int index) const {
115
    return myParentAdditionals.at(index);
116
}
117

118

119
template<> GNETAZSourceSink*
120
GNEHierarchicalStructureParents::at(const int index) const {
121
    return myParentTAZSourceSinks.at(index);
122
}
123

124

125
template<> GNEDemandElement*
126
GNEHierarchicalStructureParents::at(const int index) const {
127
    return myParentDemandElements.at(index);
128
}
129

130

131
template<> GNEGenericData*
132
GNEHierarchicalStructureParents::at(const int index) const {
133
    return myParentGenericDatas.at(index);
134
}
135

136
// add functions
137

138
template <> void
139
GNEHierarchicalStructureParents::add(GNEJunction* parent, const int index) {
140
    if (index == -1) {
141
        myParentJunctions.push_back(parent);
142
    } else if ((index < 0) || (index > (int)myParentJunctions.size())) {
143
        myParentJunctions.insert(myParentJunctions.begin() + index, parent);
144
    } else {
145
        throw ProcessError("invalid index in GNEHierarchicalStructureParents::add");
146
    }
147
}
148

149

150
template <> void
151
GNEHierarchicalStructureParents::add(GNEEdge* parent, const int index) {
152
    if (index == -1) {
153
        myParentEdges.push_back(parent);
154
    } else if ((index < 0) || (index > (int)myParentEdges.size())) {
155
        myParentEdges.insert(myParentEdges.begin() + index, parent);
156
    } else {
157
        throw ProcessError("invalid index in GNEHierarchicalStructureParents::add");
158
    }
159
}
160

161

162
template <> void
163
GNEHierarchicalStructureParents::add(GNELane* parent, const int index) {
164
    if (index == -1) {
165
        myParentLanes.push_back(parent);
166
    } else if ((index < 0) || (index > (int)myParentLanes.size())) {
167
        myParentLanes.insert(myParentLanes.begin() + index, parent);
168
    } else {
169
        throw ProcessError("invalid index in GNEHierarchicalStructureParents::add");
170
    }
171
}
172

173

174
template <> void
175
GNEHierarchicalStructureParents::add(GNEAdditional* parent, const int index) {
176
    if (index == -1) {
177
        myParentAdditionals.push_back(parent);
178
    } else if ((index < 0) || (index > (int)myParentAdditionals.size())) {
179
        myParentAdditionals.insert(myParentAdditionals.begin() + index, parent);
180
    } else {
181
        throw ProcessError("invalid index in GNEHierarchicalStructureParents::add");
182
    }
183
}
184

185

186
template <> void
187
GNEHierarchicalStructureParents::add(GNETAZSourceSink* parent, const int index) {
188
    if (index == -1) {
189
        myParentTAZSourceSinks.push_back(parent);
190
    } else if ((index < 0) || (index > (int)myParentTAZSourceSinks.size())) {
191
        myParentTAZSourceSinks.insert(myParentTAZSourceSinks.begin() + index, parent);
192
    } else {
193
        throw ProcessError("invalid index in GNEHierarchicalStructureParents::add");
194
    }
195
}
196

197

198
template <> void
199
GNEHierarchicalStructureParents::add(GNEDemandElement* parent, const int index) {
200
    if (index == -1) {
201
        myParentDemandElements.push_back(parent);
202
    } else if ((index < 0) || (index > (int)myParentDemandElements.size())) {
203
        myParentDemandElements.insert(myParentDemandElements.begin() + index, parent);
204
    } else {
205
        throw ProcessError("invalid index in GNEHierarchicalStructureParents::add");
206
    }
207
}
208

209

210
template <> void
211
GNEHierarchicalStructureParents::add(GNEGenericData* parent, const int index) {
212
    if (index == -1) {
213
        myParentGenericDatas.push_back(parent);
214
    } else if ((index < 0) || (index > (int)myParentGenericDatas.size())) {
215
        myParentGenericDatas.insert(myParentGenericDatas.begin() + index, parent);
216
    } else {
217
        throw ProcessError("invalid index in GNEHierarchicalStructureParents::add");
218
    }
219
}
220

221
// remove functions
222

223
template <> void
224
GNEHierarchicalStructureParents::remove(GNEJunction* junction) {
225
    auto it = std::find(myParentJunctions.begin(), myParentJunctions.end(), junction);
226
    if (it != myParentJunctions.end()) {
227
        myParentJunctions.erase(it);
228
    } else {
229
        throw ProcessError(junction->getTagStr() + " with ID='" + junction->getID() + "' is not a parent parent");
230
    }
231
}
232

233

234
template <> void
235
GNEHierarchicalStructureParents::remove(GNEEdge* edge) {
236
    auto it = std::find(myParentEdges.begin(), myParentEdges.end(), edge);
237
    if (it != myParentEdges.end()) {
238
        myParentEdges.erase(it);
239
    } else {
240
        throw ProcessError(edge->getTagStr() + " with ID='" + edge->getID() + "' is not a parent parent");
241
    }
242
}
243

244

245
template <> void
246
GNEHierarchicalStructureParents::remove(GNELane* lane) {
247
    auto it = std::find(myParentLanes.begin(), myParentLanes.end(), lane);
248
    if (it != myParentLanes.end()) {
249
        myParentLanes.erase(it);
250
    } else {
251
        throw ProcessError(lane->getTagStr() + " with ID='" + lane->getID() + "' is not a parent parent");
252
    }
253
}
254

255

256
template <> void
257
GNEHierarchicalStructureParents::remove(GNEAdditional* additional) {
258
    auto it = std::find(myParentAdditionals.begin(), myParentAdditionals.end(), additional);
259
    if (it != myParentAdditionals.end()) {
260
        myParentAdditionals.erase(it);
261
    } else {
262
        throw ProcessError(additional->getTagStr() + " with ID='" + additional->getID() + "' is not a parent parent");
263
    }
264
}
265

266

267
template <> void
268
GNEHierarchicalStructureParents::remove(GNETAZSourceSink* TAZSourceSink) {
269
    auto it = std::find(myParentTAZSourceSinks.begin(), myParentTAZSourceSinks.end(), TAZSourceSink);
270
    if (it != myParentTAZSourceSinks.end()) {
271
        myParentTAZSourceSinks.erase(it);
272
    } else {
273
        throw ProcessError(TAZSourceSink->getTagStr() + " with ID='" + TAZSourceSink->getID() + "' is not a parent parent");
274
    }
275
}
276

277

278
template <> void
279
GNEHierarchicalStructureParents::remove(GNEDemandElement* demandElement) {
280
    auto it = std::find(myParentDemandElements.begin(), myParentDemandElements.end(), demandElement);
281
    if (it != myParentDemandElements.end()) {
282
        myParentDemandElements.erase(it);
283
    } else {
284
        throw ProcessError(demandElement->getTagStr() + " is not a parent parent");
285
    }
286
}
287

288

289
template <> void
290
GNEHierarchicalStructureParents::remove(GNEGenericData* genericData) {
291
    auto it = std::find(myParentGenericDatas.begin(), myParentGenericDatas.end(), genericData);
292
    if (it != myParentGenericDatas.end()) {
293
        myParentGenericDatas.erase(it);
294
    } else {
295
        throw ProcessError(genericData->getTagStr() + " is not a parent parent");
296
    }
297
}
298

299
// updateParentElement functions
300

301
template <> void
302
GNEHierarchicalStructureParents::replaceSingle(const int index, GNEJunction* newParent) {
303
    if ((index >= 0) && (index < (int)myParentJunctions.size())) {
304
        myParentJunctions[index] = newParent;
305
    } else {
306
        throw ProcessError("Invalid index " + toString(newParent->getID()) + " updating junction parents");
307
    }
308
}
309

310

311
template <> void
312
GNEHierarchicalStructureParents::replaceSingle(const int index, GNEEdge* newParent) {
313
    if ((index >= 0) && (index < (int)myParentEdges.size())) {
314
        myParentEdges[index] = newParent;
315
    } else {
316
        throw ProcessError("Invalid index " + toString(newParent->getID()) + " updating edge parents");
317
    }
318
}
319

320

321
template <> void
322
GNEHierarchicalStructureParents::replaceSingle(const int index, GNELane* newParent) {
323
    if ((index >= 0) && (index < (int)myParentLanes.size())) {
324
        myParentLanes[index] = newParent;
325
    } else {
326
        throw ProcessError("Invalid index " + toString(newParent->getID()) + " updating lane parents");
327
    }
328
}
329

330

331
template <> void
332
GNEHierarchicalStructureParents::replaceSingle(const int index, GNEAdditional* newParent) {
333
    if ((index >= 0) && (index < (int)myParentAdditionals.size())) {
334
        myParentAdditionals[index] = newParent;
335
    } else {
336
        throw ProcessError("Invalid index " + toString(newParent->getID()) + " updating additional parents");
337
    }
338
}
339

340

341
template <> void
342
GNEHierarchicalStructureParents::replaceSingle(const int index, GNETAZSourceSink* newParent) {
343
    if ((index >= 0) && (index < (int)myParentTAZSourceSinks.size())) {
344
        myParentTAZSourceSinks[index] = newParent;
345
    } else {
346
        throw ProcessError("Invalid index " + toString(newParent->getID()) + " updating sourceSink parents");
347
    }
348
}
349

350

351
template <> void
352
GNEHierarchicalStructureParents::replaceSingle(const int index, GNEDemandElement* newParent) {
353
    if ((index >= 0) && (index < (int)myParentDemandElements.size())) {
354
        myParentDemandElements[index] = newParent;
355
    } else {
356
        throw ProcessError("Invalid index " + toString(newParent->getID()) + " updating demand parent parents");
357
    }
358
}
359

360

361
template <> void
362
GNEHierarchicalStructureParents::replaceSingle(const int index, GNEGenericData* newParent) {
363
    if ((index >= 0) && (index < (int)myParentGenericDatas.size())) {
364
        myParentGenericDatas[index] = newParent;
365
    } else {
366
        throw ProcessError("Invalid index " + toString(newParent->getID()) + " updating generic data parents");
367
    }
368
}
369

370
// updateParents functions
371

372
template <> void
373
GNEHierarchicalStructureParents::replaceAll(const GNEHierarchicalContainerParents<GNEJunction*>& newParents) {
374
    myParentJunctions = newParents;
375
}
376

377

378
template <> void
379
GNEHierarchicalStructureParents::replaceAll(const GNEHierarchicalContainerParents<GNEEdge*>& newParents) {
380
    myParentEdges = newParents;
381
}
382

383

384
template <> void
385
GNEHierarchicalStructureParents::replaceAll(const GNEHierarchicalContainerParents<GNELane*>& newParents) {
386
    myParentLanes = newParents;
387
}
388

389

390
template <> void
391
GNEHierarchicalStructureParents::replaceAll(const GNEHierarchicalContainerParents<GNEAdditional*>& newParents) {
392
    myParentAdditionals = newParents;
393
}
394

395

396
template <> void
397
GNEHierarchicalStructureParents::replaceAll(const GNEHierarchicalContainerParents<GNETAZSourceSink*>& newParents) {
398
    myParentTAZSourceSinks = newParents;
399
}
400

401

402
template <> void
403
GNEHierarchicalStructureParents::replaceAll(const GNEHierarchicalContainerParents<GNEDemandElement*>& newParents) {
404
    myParentDemandElements = newParents;
405
}
406

407

408
template <> void
409
GNEHierarchicalStructureParents::replaceAll(const GNEHierarchicalContainerParents<GNEGenericData*>& newParents) {
410
    myParentGenericDatas = newParents;
411
}
412

413
/****************************************************************************/
414

415
Product

Resources

Company
