Skip to content

Commit cfed62f

Browse files
lelandaisblelandaisb
committed
Remove home made container for mesh entities
1 parent 8a45b85 commit cfed62f

17 files changed

+119
-267
lines changed

‎src/Core/Mesh/Cloud.cpp‎

Lines changed: 16 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -101,34 +101,34 @@ TkUtil::UTF8String & operator << (TkUtil::UTF8String & o, const Cloud & cl)
101101
/*----------------------------------------------------------------------------*/
102102
void Cloud::addCoEdge(Topo::CoEdge* ed)
103103
{
104-
m_topo_property->getCoEdgeContainer().add(ed);
104+
m_topo_property->getCoEdgeContainer().push_back(ed);
105105
}
106106
/*----------------------------------------------------------------------------*/
107107
void Cloud::removeCoEdge(Topo::CoEdge* ed)
108108
{
109-
m_topo_property->getCoEdgeContainer().remove(ed, true);
109+
Utils::remove(ed, m_topo_property->getCoEdgeContainer());
110110
}
111111
/*----------------------------------------------------------------------------*/
112-
void Cloud::getCoEdges(std::vector<Topo::CoEdge* >& edges) const
112+
const std::vector<Topo::CoEdge* >& Cloud::getCoEdges() const
113113
{
114-
m_topo_property->getCoEdgeContainer().checkIfDestroyed();
115-
m_topo_property->getCoEdgeContainer().get(edges);
114+
Utils::checkIfDestroyed(m_topo_property->getCoEdgeContainer());
115+
return m_topo_property->getCoEdgeContainer();
116116
}
117117
/*----------------------------------------------------------------------------*/
118118
void Cloud::addVertex(Topo::Vertex* vtx)
119119
{
120-
m_topo_property->getVertexContainer().add(vtx);
120+
m_topo_property->getVertexContainer().push_back(vtx);
121121
}
122122
/*----------------------------------------------------------------------------*/
123123
void Cloud::removeVertex(Topo::Vertex* vtx)
124124
{
125-
m_topo_property->getVertexContainer().remove(vtx, true);
125+
Utils::remove(vtx, m_topo_property->getVertexContainer());
126126
}
127127
/*----------------------------------------------------------------------------*/
128-
void Cloud::getVertices(std::vector<Topo::Vertex* >& vertices) const
128+
const std::vector<Topo::Vertex* >& Cloud::getVertices() const
129129
{
130-
m_topo_property->getVertexContainer().checkIfDestroyed();
131-
m_topo_property->getVertexContainer().get(vertices);
130+
Utils::checkIfDestroyed(m_topo_property->getVertexContainer());
131+
return m_topo_property->getVertexContainer();
132132
}
133133
/*----------------------------------------------------------------------------*/
134134
Utils::SerializedRepresentation* Cloud::
@@ -140,10 +140,8 @@ getDescription (bool alsoComputed) const
140140
// le maillage vu depuis les arêtes et celui stocké dans GMDS
141141
Utils::SerializedRepresentation meshProprietes ("Propriétés du maillage", "");
142142

143-
std::vector<Topo::CoEdge* > coedges;
144-
getCoEdges(coedges);
145-
std::vector<Topo::Vertex* > vertices;
146-
getVertices(vertices);
143+
auto coedges = getCoEdges();
144+
auto vertices = getVertices();
147145

148146
uint nbNodes = 0;
149147
for (uint i=0; i<coedges.size(); i++){
@@ -194,11 +192,6 @@ void Cloud::getGMDSNodes(std::vector<gmds::Node >& ANodes) const
194192
{
195193
ANodes.clear();
196194

197-
std::vector<Topo::CoEdge* > coEdges;
198-
getCoEdges(coEdges);
199-
std::vector<Topo::Vertex* > vertices;
200-
getVertices(vertices);
201-
202195
Mesh::MeshItf* meshItf = getMeshManager ( ).getMesh ( );
203196
Mesh::MeshImplementation* meshImpl =
204197
dynamic_cast<Mesh::MeshImplementation*> (meshItf);
@@ -208,17 +201,17 @@ void Cloud::getGMDSNodes(std::vector<gmds::Node >& ANodes) const
208201
// ajout d'un filtre pour éviter de mettre 2 fois (ou plus) un même noeud
209202
std::map<gmds::TCellID, uint> filtre;
210203

211-
for(unsigned int iVertex=0; iVertex<vertices.size(); iVertex++) {
212-
gmds::TCellID node = vertices[iVertex]->getNode();
204+
for(Topo::Vertex* vtx : getVertices()) {
205+
gmds::TCellID node = vtx->getNode();
213206

214207
if (filtre[node] == 0){
215208
ANodes.push_back(gmdsMesh.get<gmds::Node>(node));
216209
filtre[node] = 1;
217210
}
218211
}
219212

220-
for(unsigned int iCoEdge=0; iCoEdge<coEdges.size(); iCoEdge++) {
221-
std::vector<gmds::TCellID> nodes = coEdges[iCoEdge]->nodes();
213+
for(Topo::CoEdge* coedge : getCoEdges()) {
214+
std::vector<gmds::TCellID> nodes = coedge->nodes();
222215

223216
for(unsigned int iNode=0; iNode<nodes.size(); iNode++) {
224217
if (filtre[nodes[iNode]] == 0){

‎src/Core/Mesh/Line.cpp‎

Lines changed: 8 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -100,18 +100,18 @@ TkUtil::UTF8String & operator << (TkUtil::UTF8String & o, const Line & cl)
100100
/*----------------------------------------------------------------------------*/
101101
void Line::addCoEdge(Topo::CoEdge* ed)
102102
{
103-
m_topo_property->getCoEdgeContainer().add(ed);
103+
m_topo_property->getCoEdgeContainer().push_back(ed);
104104
}
105105
/*----------------------------------------------------------------------------*/
106106
void Line::removeCoEdge(Topo::CoEdge* ed)
107107
{
108-
m_topo_property->getCoEdgeContainer().remove(ed, true);
108+
Utils::remove(ed, m_topo_property->getCoEdgeContainer());
109109
}
110110
/*----------------------------------------------------------------------------*/
111-
void Line::getCoEdges(std::vector<Topo::CoEdge* >& edges) const
111+
const std::vector<Topo::CoEdge* >& Line::getCoEdges() const
112112
{
113-
m_topo_property->getCoEdgeContainer().checkIfDestroyed();
114-
m_topo_property->getCoEdgeContainer().get(edges);
113+
Utils::checkIfDestroyed(m_topo_property->getCoEdgeContainer());
114+
return m_topo_property->getCoEdgeContainer();
115115
}
116116
/*----------------------------------------------------------------------------*/
117117
Utils::SerializedRepresentation* Line::
@@ -123,8 +123,7 @@ getDescription (bool alsoComputed) const
123123
// le maillage vu depuis les arêtes et celui stocké dans GMDS
124124
Utils::SerializedRepresentation meshProprietes ("Propriétés du maillage", "");
125125

126-
std::vector<Topo::CoEdge* > coedges;
127-
getCoEdges(coedges);
126+
auto coedges = getCoEdges();
128127

129128
uint nbEdges = 0;
130129
for (uint i=0; i<coedges.size(); i++){
@@ -158,17 +157,14 @@ void Line::getGMDSEdges(std::vector<gmds::Edge >& AEdges) const
158157
{
159158
AEdges.clear();
160159

161-
std::vector<Topo::CoEdge* > coEdges;
162-
getCoEdges(coEdges);
163-
164160
Mesh::MeshItf* meshItf = getMeshManager ( ).getMesh ( );
165161
Mesh::MeshImplementation* meshImpl =
166162
dynamic_cast<Mesh::MeshImplementation*> (meshItf);
167163
CHECK_NULL_PTR_ERROR(meshImpl);
168164
gmds::Mesh& gmdsMesh = meshImpl->getGMDSMesh();
169165

170-
for(unsigned int iCoEdge=0; iCoEdge<coEdges.size(); iCoEdge++) {
171-
std::vector<gmds::TCellID> edges = coEdges[iCoEdge]->edges();
166+
for(Topo::CoEdge* coedge : getCoEdges()) {
167+
std::vector<gmds::TCellID> edges = coedge->edges();
172168

173169
for(unsigned int iEdge=0; iEdge<edges.size(); iEdge++) {
174170
AEdges.push_back(gmdsMesh.get<gmds::Edge>(edges[iEdge]));

‎src/Core/Mesh/MeshImplementation.cpp‎

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -267,9 +267,6 @@ bool MeshImplementation::createGMDSGroups()
267267
auto su = getGMDSMesh().newGroup<gmds::Face>(current_surf->getName());
268268
createdGMDSSurfaces.push_back(su);
269269

270-
std::vector<Topo::CoFace* > coFaces;
271-
current_surf->getCoFaces(coFaces);
272-
273270
std::vector<gmds::Face> faces;
274271
current_surf->getGMDSFaces(faces);
275272

@@ -283,9 +280,6 @@ bool MeshImplementation::createGMDSGroups()
283280
auto vo = getGMDSMesh().newGroup<gmds::Region>(current_vol->getName());
284281
createdGMDSVolumes.push_back(vo);
285282

286-
std::vector<Topo::Block* > blocks;
287-
current_vol->getBlocks(blocks);
288-
289283
std::vector<gmds::Region> regions;
290284
current_vol->getGMDSRegions(regions);
291285

‎src/Core/Mesh/Surface.cpp‎

Lines changed: 12 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -240,34 +240,31 @@ TkUtil::UTF8String & operator << (TkUtil::UTF8String & o, const Surface & cl)
240240
/*----------------------------------------------------------------------------*/
241241
void Surface::addCoFace(Topo::CoFace* f)
242242
{
243-
m_topo_property->getCoFaceContainer().add(f);
243+
m_topo_property->getCoFaceContainer().push_back(f);
244244
}
245245
/*----------------------------------------------------------------------------*/
246246
void Surface::removeCoFace(Topo::CoFace* f)
247247
{
248-
m_topo_property->getCoFaceContainer().remove(f, true);
248+
Utils::remove(f, m_topo_property->getCoFaceContainer());
249249
}
250250
/*----------------------------------------------------------------------------*/
251-
void Surface::getCoFaces(std::vector<Topo::CoFace* >& faces) const
251+
const std::vector<Topo::CoFace* >& Surface::getCoFaces() const
252252
{
253-
m_topo_property->getCoFaceContainer().checkIfDestroyed();
254-
m_topo_property->getCoFaceContainer().get(faces);
253+
Utils::checkIfDestroyed(m_topo_property->getCoFaceContainer());
254+
return m_topo_property->getCoFaceContainer();
255255
}
256256
/*----------------------------------------------------------------------------*/
257257
void Surface::getGMDSFaces(std::vector<gmds::Face >& AFaces) const
258258
{
259259
AFaces.clear();
260260

261-
std::vector<Topo::CoFace* > coFaces;
262-
getCoFaces(coFaces);
263-
264261
Mesh::MeshItf* meshItf = getMeshManager ( ).getMesh ( );
265262
Mesh::MeshImplementation* meshImpl = dynamic_cast<Mesh::MeshImplementation*> (meshItf);
266263
CHECK_NULL_PTR_ERROR(meshImpl);
267264
gmds::Mesh& gmdsMesh = meshImpl->getGMDSMesh();
268265

269-
for(unsigned int iCoFace=0; iCoFace<coFaces.size(); iCoFace++) {
270-
std::vector<gmds::TCellID> faces = coFaces[iCoFace]->faces();
266+
for(Topo::CoFace* coface : getCoFaces()) {
267+
std::vector<gmds::TCellID> faces = coface->faces();
271268

272269
for(unsigned int iFace=0; iFace<faces.size(); iFace++) {
273270
AFaces.push_back(gmdsMesh.get<gmds::Face>(faces[iFace]));
@@ -282,16 +279,13 @@ void Surface::getGMDSNodes(std::vector<gmds::Node>& ANodes) const
282279
// utilisation d'un filtre pour ne pas référencer plusieurs fois un même noeud
283280
std::map<gmds::TCellID, uint> filtre_nodes;
284281

285-
std::vector<Topo::CoFace* > coFaces;
286-
getCoFaces(coFaces);
287-
288282
Mesh::MeshItf* meshItf = getMeshManager ( ).getMesh ( );
289283
Mesh::MeshImplementation* meshImpl = dynamic_cast<Mesh::MeshImplementation*> (meshItf);
290284
CHECK_NULL_PTR_ERROR(meshImpl);
291285
gmds::Mesh& gmdsMesh = meshImpl->getGMDSMesh();
292286

293-
for(unsigned int iCoFace=0; iCoFace<coFaces.size(); iCoFace++) {
294-
std::vector<gmds::TCellID> nodes = coFaces[iCoFace]->nodes();
287+
for(Topo::CoFace* coface : getCoFaces()) {
288+
std::vector<gmds::TCellID> nodes = coface->nodes();
295289

296290
for(unsigned int iNode=0; iNode<nodes.size(); iNode++) {
297291
if (filtre_nodes[nodes[iNode]] == 0){
@@ -308,8 +302,7 @@ getDescription (bool alsoComputed) const
308302
std::unique_ptr<Utils::SerializedRepresentation> description (
309303
MeshEntity::getDescription (alsoComputed));
310304

311-
std::vector<Topo::CoFace* > faces;
312-
getCoFaces(faces);
305+
auto faces = getCoFaces();
313306

314307
// le maillage vu depuis les cofaces
315308
Utils::SerializedRepresentation meshProprietes ("Propriétés du maillage", "");
@@ -375,10 +368,8 @@ saveInternals(Mesh::CommandCreateMesh* ccm)
375368
bool Surface::
376369
isStructured()
377370
{
378-
std::vector<Topo::CoFace* > coFaces;
379-
getCoFaces(coFaces);
380-
for(unsigned int iCoFace=0; iCoFace<coFaces.size(); iCoFace++)
381-
if (!coFaces[iCoFace]->isStructured())
371+
for(Topo::CoFace* coface : getCoFaces())
372+
if (!coface->isStructured())
382373
return false;
383374

384375
return true;

‎src/Core/Mesh/Volume.cpp‎

Lines changed: 13 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -233,15 +233,12 @@ void Volume::getRepresentation(Utils::DisplayRepresentation& dr, bool checkDestr
233233
{ // On prend la peau du maillage
234234
// on passe par GMDS pour récupérer les noeuds et les mailles :
235235
gmds::Mesh& gmdsMesh = meshImpl->getGMDSMesh ( );
236-
// la liste des Topo::Block qui ont contribués :
237-
std::vector<Topo::Block* > blocs;
238-
getBlocks (blocs);
239236

240237
// la liste des faces externes au groupe de blocs
241238
// on utilise une map et on marque les faces à chaque fois
242239
// qu'elles sont vus
243240
std::map<Topo::CoFace*, int> marque_faces;
244-
for (Topo::Block* bloc : blocs)
241+
for (Topo::Block* bloc : getBlocks())
245242
for (Topo::Face* face : bloc->getFaces())
246243
for (Topo::CoFace* coface : face->getCoFaces())
247244
marque_faces[coface] += 1;
@@ -335,34 +332,31 @@ TkUtil::UTF8String & operator << (TkUtil::UTF8String & o, const Volume & cl)
335332
/*----------------------------------------------------------------------------*/
336333
void Volume::addBlock(Topo::Block* b)
337334
{
338-
m_topo_property->getBlockContainer().add(b);
335+
m_topo_property->getBlockContainer().push_back(b);
339336
}
340337
/*----------------------------------------------------------------------------*/
341338
void Volume::removeBlock(Topo::Block* b)
342339
{
343-
m_topo_property->getBlockContainer().remove(b, true);
340+
Utils::remove(b, m_topo_property->getBlockContainer());
344341
}
345342
/*----------------------------------------------------------------------------*/
346-
void Volume::getBlocks(std::vector<Topo::Block* >& blocks) const
343+
const std::vector<Topo::Block* >& Volume::getBlocks() const
347344
{
348-
m_topo_property->getBlockContainer().checkIfDestroyed();
349-
m_topo_property->getBlockContainer().get(blocks);
345+
Utils::checkIfDestroyed(m_topo_property->getBlockContainer());
346+
return m_topo_property->getBlockContainer();
350347
}
351348
/*----------------------------------------------------------------------------*/
352349
void Volume::getGMDSRegions(std::vector<gmds::Region >& ARegions) const
353350
{
354351
ARegions.clear();
355352

356-
std::vector<Topo::Block* > blocks;
357-
getBlocks(blocks);
358-
359353
Mesh::MeshItf* meshItf = getMeshManager ( ).getMesh ( );
360354
Mesh::MeshImplementation* meshImpl =
361355
dynamic_cast<Mesh::MeshImplementation*> (meshItf);
362356
CHECK_NULL_PTR_ERROR(meshImpl);
363357
gmds::Mesh& gmdsMesh = meshImpl->getGMDSMesh ( );
364-
for(unsigned int iBlock=0; iBlock<blocks.size(); iBlock++) {
365-
std::vector<gmds::TCellID> regions = blocks[iBlock]->regions();
358+
for(Topo::Block* block : getBlocks()) {
359+
std::vector<gmds::TCellID> regions = block->regions();
366360

367361
for(unsigned int iRegion=0; iRegion<regions.size(); iRegion++) {
368362
ARegions.push_back(gmdsMesh.get<gmds::Region>(regions[iRegion]));
@@ -377,16 +371,13 @@ void Volume::getGMDSNodes(std::vector<gmds::Node>& ANodes) const
377371
// utilisation d'un filtre pour ne pas référencer plusieurs fois un même noeud
378372
std::map<gmds::TCellID, uint> filtre_nodes;
379373

380-
std::vector<Topo::Block* > blocks;
381-
getBlocks(blocks);
382-
383374
Mesh::MeshItf* meshItf = getMeshManager ( ).getMesh ( );
384375
Mesh::MeshImplementation* meshImpl = dynamic_cast<Mesh::MeshImplementation*> (meshItf);
385376
CHECK_NULL_PTR_ERROR(meshImpl);
386377
gmds::Mesh& gmdsMesh = meshImpl->getGMDSMesh();
387378

388-
for(unsigned int iBlock=0; iBlock<blocks.size(); iBlock++) {
389-
std::vector<gmds::TCellID> nodes = blocks[iBlock]->nodes();
379+
for(Topo::Block* block : getBlocks()) {
380+
std::vector<gmds::TCellID> nodes = block->nodes();
390381

391382
for(unsigned int iNode=0; iNode<nodes.size(); iNode++) {
392383
if (filtre_nodes[nodes[iNode]] == 0){
@@ -403,8 +394,7 @@ getDescription (bool alsoComputed) const
403394
std::unique_ptr<Utils::SerializedRepresentation> description (
404395
MeshEntity::getDescription (alsoComputed));
405396

406-
std::vector<Topo::Block* > blocks;
407-
getBlocks(blocks);
397+
auto blocks = getBlocks();
408398

409399
if (!blocks.empty()){
410400
// le maillage vu depuis les blocs
@@ -495,10 +485,8 @@ saveInternals(Mesh::CommandCreateMesh* ccm)
495485
bool Volume::
496486
isStructured()
497487
{
498-
std::vector<Topo::Block* > blocs;
499-
getBlocks(blocs);
500-
for(unsigned int i=0; i<blocs.size(); i++)
501-
if (!blocs[i]->isStructured())
488+
for(Topo::Block* block : getBlocks())
489+
if (!block->isStructured())
502490
return false;
503491

504492
return true;

‎src/Core/protected/Mesh/Cloud.h‎

Lines changed: 2 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,3 @@
1-
/*----------------------------------------------------------------------------*/
2-
/*
3-
* \file Cloud.h
4-
*
5-
* \author Eric Brière de l'Isle
6-
*
7-
* \date 25 nov. 2011
8-
*/
9-
/*----------------------------------------------------------------------------*/
101
#ifndef MGX3D_MESH_CLOUD_H_
112
#define MGX3D_MESH_CLOUD_H_
123
/*----------------------------------------------------------------------------*/
@@ -122,7 +113,7 @@ class Cloud : public MeshEntity {
122113
#endif
123114

124115
/// Fournit l'accès aux arêtes topologiques qui ont participées à la constitution du nuage
125-
void getCoEdges(std::vector<Topo::CoEdge* >& edges) const;
116+
const std::vector<Topo::CoEdge* >& getCoEdges() const;
126117

127118
/** supprime les relations vers les arêtes */
128119
void clearCoEdges()
@@ -140,7 +131,7 @@ class Cloud : public MeshEntity {
140131
#endif
141132

142133
/// Fournit l'accès aux sommets topologiques qui ont participées à la constitution du nuage
143-
void getVertices(std::vector<Topo::Vertex* >& vertices) const;
134+
const std::vector<Topo::Vertex* >& getVertices() const;
144135

145136
/** supprime les relations vers les sommets */
146137
void clearVertices()

0 commit comments

Comments
 (0)