3748625157

Build Type

push

github

Committed by GitHub

Commit Message

Fix#391 (#439)

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

8869 of 9910 relevant lines covered (89.5%)

76013.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.41

/mdal/mdal_data_model.cpp

/*
 MDAL - Mesh Data Abstraction Library (MIT License)
 Copyright (C) 2018 Peter Petrik (zilolv at gmail dot com)
*/

#include "mdal_data_model.hpp"
#include <assert.h>
#include <math.h>
#include <algorithm>
#include "mdal_utils.hpp"

MDAL::Dataset::~Dataset() = default;

MDAL::Dataset::Dataset( MDAL::DatasetGroup *parent )
  : mParent( parent )
{
  assert( mParent );
}

size_t MDAL::Dataset::valuesCount() const
{
  const MDAL_DataLocation location = group()->dataLocation();

  switch ( location )
  {
    case MDAL_DataLocation::DataOnVertices: return mesh()->verticesCount();
    case MDAL_DataLocation::DataOnFaces: return mesh()->facesCount();
    case MDAL_DataLocation::DataOnVolumes: return volumesCount();
    case MDAL_DataLocation::DataOnEdges: return mesh()->edgesCount();
    default: return 0;
  }
}

size_t MDAL::Dataset::activeData( size_t, size_t, int * )
{
  assert( !supportsActiveFlag() );
  return 0;
}

MDAL::Statistics MDAL::Dataset::statistics() const
{
  return mStatistics;
}

void MDAL::Dataset::setStatistics( const MDAL::Statistics &statistics )
{
  mStatistics = statistics;
}

MDAL::DatasetGroup *MDAL::Dataset::group() const
{
  return mParent;
}

MDAL::Mesh *MDAL::Dataset::mesh() const
{
  return mParent->mesh();
}

double MDAL::Dataset::time( RelativeTimestamp::Unit unit ) const
{
  return mTime.value( unit );
}

MDAL::RelativeTimestamp MDAL::Dataset::timestamp() const
{
  return mTime;
}

void MDAL::Dataset::setTime( double time, RelativeTimestamp::Unit unit )
{
  mTime = RelativeTimestamp( time, unit );
}

void MDAL::Dataset::setTime( const MDAL::RelativeTimestamp &time )
{
  mTime = time;
}

bool MDAL::Dataset::supportsActiveFlag() const
{
  return mSupportsActiveFlag;
}

void MDAL::Dataset::setSupportsActiveFlag( bool value )
{
  mSupportsActiveFlag = value;
}

bool MDAL::Dataset::isValid() const
{
  return mIsValid;
}

MDAL::Dataset2D::Dataset2D( MDAL::DatasetGroup *parent )
  : Dataset( parent )
{
}

MDAL::Dataset2D::~Dataset2D() = default;

size_t MDAL::Dataset2D::volumesCount() const { return 0; }

size_t MDAL::Dataset2D::maximumVerticalLevelsCount() const { return 0; }

size_t MDAL::Dataset2D::verticalLevelCountData( size_t, size_t, int * ) { return 0; }

size_t MDAL::Dataset2D::verticalLevelData( size_t, size_t, double * ) { return 0; }

size_t MDAL::Dataset2D::faceToVolumeData( size_t, size_t, int * ) { return 0; }

size_t MDAL::Dataset2D::scalarVolumesData( size_t, size_t, double * ) { return 0; }

size_t MDAL::Dataset2D::vectorVolumesData( size_t, size_t, double * ) { return 0; }

MDAL::Dataset3D::Dataset3D( MDAL::DatasetGroup *parent, size_t volumes, size_t maxVerticalLevelCount )
  : Dataset( parent )
  , mVolumesCount( volumes )
  , mMaximumVerticalLevelsCount( maxVerticalLevelCount )
{
}

MDAL::Dataset3D::~Dataset3D() = default;

size_t MDAL::Dataset3D::volumesCount() const
{
  return mVolumesCount;
}

size_t MDAL::Dataset3D::maximumVerticalLevelsCount() const
{
  return mMaximumVerticalLevelsCount;
}

size_t MDAL::Dataset3D::scalarData( size_t, size_t, double * ) { return 0; }

size_t MDAL::Dataset3D::vectorData( size_t, size_t, double * ) { return 0; }

MDAL::DatasetGroup::DatasetGroup( const std::string &driverName,
                                  MDAL::Mesh *parent,
                                  const std::string &uri,
                                  const std::string &name )
  : mDriverName( driverName )
  , mParent( parent )
  , mUri( uri )
{
  assert( mParent );
  setName( name );
}

std::string MDAL::DatasetGroup::driverName() const
{
  return mDriverName;
}

MDAL::DatasetGroup::~DatasetGroup() = default;

MDAL::DatasetGroup::DatasetGroup( const std::string &driverName,
                                  MDAL::Mesh *parent,
                                  const std::string &uri )
  : mDriverName( driverName )
  , mParent( parent )
  , mUri( uri )
{
  assert( mParent );
}

std::string MDAL::DatasetGroup::getMetadata( const std::string &key )
{
  for ( auto &pair : metadata )
  {
    if ( pair.first == key )
    {
      return pair.second;
    }
  }
  return std::string();
}

void MDAL::DatasetGroup::setMetadata( const std::string &key, const std::string &val )
{
  bool found = false;
  for ( auto &pair : metadata )
  {
    if ( pair.first == key )
    {
      found = true;
      pair.second = val;
    }
  }
  if ( !found )
    metadata.push_back( std::make_pair( key, val ) );
}

void MDAL::DatasetGroup::setMetadata( const MDAL::Metadata &new_metadata )
{
  for ( const auto &meta : new_metadata )
    setMetadata( meta.first, meta.second );
}

std::string MDAL::DatasetGroup::name()
{
  return getMetadata( "name" );
}

void MDAL::DatasetGroup::setName( const std::string &name )
{
  setMetadata( "name", name );
}

std::string MDAL::DatasetGroup::uri() const
{
  return mUri;
}

void MDAL::DatasetGroup::replaceUri( std::string uri )
{
  mUri = uri;
}

MDAL::Statistics MDAL::DatasetGroup::statistics() const
{
  return mStatistics;
}

void MDAL::DatasetGroup::setStatistics( const Statistics &statistics )
{
  mStatistics = statistics;
}

MDAL::DateTime MDAL::DatasetGroup::referenceTime() const
{
  return mReferenceTime;
}

void MDAL::DatasetGroup::setReferenceTime( const DateTime &referenceTime )
{
  mReferenceTime = referenceTime;
}

MDAL::Mesh *MDAL::DatasetGroup::mesh() const
{
  return mParent;
}

size_t MDAL::DatasetGroup::maximumVerticalLevelsCount() const
{
  size_t maxLevels = 0;
  for ( const std::shared_ptr<Dataset> &ds : datasets )
  {
    const size_t maxDsLevels = ds->maximumVerticalLevelsCount();
    if ( maxDsLevels > maxLevels )
      return maxLevels = maxDsLevels;
  }
  return maxLevels;
}

bool MDAL::DatasetGroup::isInEditMode() const
{
  return mInEditMode;
}

void MDAL::DatasetGroup::startEditing()
{
  mInEditMode = true;
}

void MDAL::DatasetGroup::stopEditing()
{
  mInEditMode = false;
}

void MDAL::DatasetGroup::setReferenceAngles( const std::pair<double, double> &referenceAngle )
{
  mReferenceAngles = referenceAngle;
}

bool MDAL::DatasetGroup::isPolar() const
{
  return mIsPolar;
}

void MDAL::DatasetGroup::setIsPolar( bool isPolar )
{
  mIsPolar = isPolar;
}

std::pair<double, double> MDAL::DatasetGroup::referenceAngles() const
{
  return mReferenceAngles;
}

MDAL_DataLocation MDAL::DatasetGroup::dataLocation() const
{
  return mDataLocation;
}

void MDAL::DatasetGroup::setDataLocation( MDAL_DataLocation dataLocation )
{
  // datasets are initialized (e.g. values array, active array) based
  // on this property. Do not allow to modify later on.
  assert( datasets.empty() );
  mDataLocation = dataLocation;
}

bool MDAL::DatasetGroup::isScalar() const
{
  return mIsScalar;
}

void MDAL::DatasetGroup::setIsScalar( bool isScalar )
{
  // datasets are initialized (e.g. values array, active array) based
  // on this property. Do not allow to modify later on.
  assert( datasets.empty() );
  mIsScalar = isScalar;
}

MDAL::Mesh::Mesh( const std::string &driverName,
                  size_t faceVerticesMaximumCount,
                  const std::string &uri )
  : mDriverName( driverName )
  , mFaceVerticesMaximumCount( faceVerticesMaximumCount )
  , mUri( uri )
{
}

std::string MDAL::Mesh::driverName() const
{
  return mDriverName;
}

MDAL::Mesh::~Mesh() = default;

std::shared_ptr<MDAL::DatasetGroup> MDAL::Mesh::group( const std::string &name )
{
  for ( auto grp : datasetGroups )
  {
    if ( grp->name() == name )
      return grp;
  }
  return std::shared_ptr<MDAL::DatasetGroup>();
}

void MDAL::Mesh::setSourceCrs( const std::string &str )
{
  mCrs = MDAL::trim( str );
}

void MDAL::Mesh::setSourceCrsFromWKT( const std::string &wkt )
{
  setSourceCrs( wkt );
}

void MDAL::Mesh::setSourceCrsFromEPSG( int code )
{
  setSourceCrs( std::string( "EPSG:" ) + std::to_string( code ) );
}

void MDAL::Mesh::setSourceCrsFromPrjFile( const std::string &filename )
{
  const std::string proj = MDAL::readFileToString( filename );
  setSourceCrs( proj );
}

std::string MDAL::Mesh::getMetadata( const std::string &key )
{
  for ( auto &pair : metadata )
  {
    if ( pair.first == key )
    {
      return pair.second;
    }
  }
  return std::string();
}

void MDAL::Mesh::setMetadata( const std::string &key, const std::string &val )
{
  bool found = false;
  for ( auto &pair : metadata )
  {
    if ( pair.first == key )
    {
      found = true;
      pair.second = val;
    }
  }
  if ( !found )
    metadata.push_back( std::make_pair( key, val ) );
}

void MDAL::Mesh::setMetadata( const MDAL::Metadata &new_metadata )
{
  for ( const auto &meta : new_metadata )
    setMetadata( meta.first, meta.second );
}


std::string MDAL::Mesh::uri() const
{
  return mUri;
}

std::string MDAL::Mesh::crs() const
{
  return mCrs;
}

size_t MDAL::Mesh::faceVerticesMaximumCount() const
{
  return mFaceVerticesMaximumCount;
}

void MDAL::Mesh::setFaceVerticesMaximumCount( const size_t &faceVerticesMaximumCount )
{
  mFaceVerticesMaximumCount = faceVerticesMaximumCount;
}

void MDAL::Mesh::addVertices( size_t vertexCount, double *coordinates )
{
  MDAL_UNUSED( vertexCount );
  MDAL_UNUSED( coordinates );
}

void MDAL::Mesh::addFaces( size_t faceCount, size_t driverMaxVerticesPerFace, int *faceSizes, int *vertexIndices )
{
  MDAL_UNUSED( faceCount );
  MDAL_UNUSED( driverMaxVerticesPerFace );
  MDAL_UNUSED( faceSizes );
  MDAL_UNUSED( vertexIndices );
}

void MDAL::Mesh::addEdges( size_t edgeCount, int *startVertexIndices, int *endVertexIndices )
{
  MDAL_UNUSED( edgeCount );
  MDAL_UNUSED( startVertexIndices );
  MDAL_UNUSED( endVertexIndices );
}


MDAL::MeshVertexIterator::~MeshVertexIterator() = default;

MDAL::MeshFaceIterator::~MeshFaceIterator() = default;

MDAL::MeshEdgeIterator::~MeshEdgeIterator() = default;

1	/*
2	MDAL - Mesh Data Abstraction Library (MIT License)
3	Copyright (C) 2018 Peter Petrik (zilolv at gmail dot com)
4	*/
5
6	#include "mdal_data_model.hpp"
7	#include <assert.h>
8	#include <math.h>
9	#include <algorithm>
10	#include "mdal_utils.hpp"
11
12	MDAL::Dataset::~Dataset() = default;	9,505✔
13
14	MDAL::Dataset::Dataset( MDAL::DatasetGroup *parent )	9,505✔
15	: mParent( parent )	9,505✔
16	{
17	assert( mParent );	9,505✔
18	}	9,505✔
19
20	size_t MDAL::Dataset::valuesCount() const	1,772,389✔
21	{
22	const MDAL_DataLocation location = group()->dataLocation();	1,772,389✔
23
24	switch ( location )	1,772,389✔
25	{
26	case MDAL_DataLocation::DataOnVertices: return mesh()->verticesCount();	11,542✔
27	case MDAL_DataLocation::DataOnFaces: return mesh()->facesCount();	1,758,292✔
28	case MDAL_DataLocation::DataOnVolumes: return volumesCount();	1,935✔
29	case MDAL_DataLocation::DataOnEdges: return mesh()->edgesCount();	620✔
30	default: return 0;	×
31	}
32	}
33
34	size_t MDAL::Dataset::activeData( size_t, size_t, int * )	×
35	{
36	assert( !supportsActiveFlag() );	×
37	return 0;	×
38	}
39
40	MDAL::Statistics MDAL::Dataset::statistics() const	8,042✔
41	{
42	return mStatistics;	8,042✔
43	}
44
45	void MDAL::Dataset::setStatistics( const MDAL::Statistics &statistics )	8,623✔
46	{
47	mStatistics = statistics;	8,623✔
48	}	8,623✔
49
50	MDAL::DatasetGroup *MDAL::Dataset::group() const	6,476,462✔
51	{
52	return mParent;	6,476,462✔
53	}
54
55	MDAL::Mesh *MDAL::Dataset::mesh() const	1,771,384✔
56	{
57	return mParent->mesh();	1,771,384✔
58	}
59
60	double MDAL::Dataset::time( RelativeTimestamp::Unit unit ) const	275✔
61	{
62	return mTime.value( unit );	275✔
63	}
64
65	MDAL::RelativeTimestamp MDAL::Dataset::timestamp() const	55✔
66	{
67	return mTime;	55✔
68	}
69
70	void MDAL::Dataset::setTime( double time, RelativeTimestamp::Unit unit )	2,184✔
71	{
72	mTime = RelativeTimestamp( time, unit );	2,184✔
73	}	2,184✔
74
75	void MDAL::Dataset::setTime( const MDAL::RelativeTimestamp &time )	7,321✔
76	{
77	mTime = time;	7,321✔
78	}	7,321✔
79
80	bool MDAL::Dataset::supportsActiveFlag() const	238,403✔
81	{
82	return mSupportsActiveFlag;	238,403✔
83	}
84
85	void MDAL::Dataset::setSupportsActiveFlag( bool value )	6,565✔
86	{
87	mSupportsActiveFlag = value;	6,565✔
88	}	6,565✔
89
90	bool MDAL::Dataset::isValid() const	140✔
91	{
92	return mIsValid;	140✔
93	}
94
95	MDAL::Dataset2D::Dataset2D( MDAL::DatasetGroup *parent )	9,078✔
96	: Dataset( parent )	9,078✔
97	{
98	}	9,078✔
99
100	MDAL::Dataset2D::~Dataset2D() = default;	9,078✔
101
102	size_t MDAL::Dataset2D::volumesCount() const { return 0; }	×
103
104	size_t MDAL::Dataset2D::maximumVerticalLevelsCount() const { return 0; }	4✔
105
106	size_t MDAL::Dataset2D::verticalLevelCountData( size_t, size_t, int * ) { return 0; }	×
107
108	size_t MDAL::Dataset2D::verticalLevelData( size_t, size_t, double * ) { return 0; }	×
109
110	size_t MDAL::Dataset2D::faceToVolumeData( size_t, size_t, int * ) { return 0; }	×
111
112	size_t MDAL::Dataset2D::scalarVolumesData( size_t, size_t, double * ) { return 0; }	×
113
114	size_t MDAL::Dataset2D::vectorVolumesData( size_t, size_t, double * ) { return 0; }	×
115
116	MDAL::Dataset3D::Dataset3D( MDAL::DatasetGroup *parent, size_t volumes, size_t maxVerticalLevelCount )	427✔
117	: Dataset( parent )
118	, mVolumesCount( volumes )	427✔
119	, mMaximumVerticalLevelsCount( maxVerticalLevelCount )	427✔
120	{
121	}	427✔
122
123	MDAL::Dataset3D::~Dataset3D() = default;	427✔
124
125	size_t MDAL::Dataset3D::volumesCount() const	4,630✔
126	{
127	return mVolumesCount;	4,630✔
128	}
129
130	size_t MDAL::Dataset3D::maximumVerticalLevelsCount() const	8✔
131	{
132	return mMaximumVerticalLevelsCount;	8✔
133	}
134
135	size_t MDAL::Dataset3D::scalarData( size_t, size_t, double * ) { return 0; }	×
136
137	size_t MDAL::Dataset3D::vectorData( size_t, size_t, double * ) { return 0; }	×
138
139	MDAL::DatasetGroup::DatasetGroup( const std::string &driverName,	887✔
140	MDAL::Mesh *parent,
141	const std::string &uri,
142	const std::string &name )	887✔
143	: mDriverName( driverName )	887✔
144	, mParent( parent )	887✔
145	, mUri( uri )	887✔
146	{
147	assert( mParent );	887✔
148	setName( name );	887✔
149	}	887✔
150
151	std::string MDAL::DatasetGroup::driverName() const	211✔
152	{
153	return mDriverName;	211✔
154	}
155
156	MDAL::DatasetGroup::~DatasetGroup() = default;	970✔
157
158	MDAL::DatasetGroup::DatasetGroup( const std::string &driverName,	83✔
159	MDAL::Mesh *parent,
160	const std::string &uri )	83✔
161	: mDriverName( driverName )	83✔
162	, mParent( parent )	83✔
163	, mUri( uri )	83✔
164	{
165	assert( mParent );	83✔
166	}	83✔
167
168	std::string MDAL::DatasetGroup::getMetadata( const std::string &key )	386✔
169	{
170	for ( auto &pair : metadata )	426✔
171	{
172	if ( pair.first == key )	414✔
173	{
174	return pair.second;	374✔
175	}
176	}
177	return std::string();	12✔
178	}
179
180	void MDAL::DatasetGroup::setMetadata( const std::string &key, const std::string &val )	1,475✔
181	{
182	bool found = false;	1,475✔
183	for ( auto &pair : metadata )	1,999✔
184	{
185	if ( pair.first == key )	524✔
186	{
187	found = true;	22✔
188	pair.second = val;	22✔
189	}
190	}
191	if ( !found )	1,475✔
192	metadata.push_back( std::make_pair( key, val ) );	1,453✔
193	}	1,475✔
194
195	void MDAL::DatasetGroup::setMetadata( const MDAL::Metadata &new_metadata )	370✔
196	{
197	for ( const auto &meta : new_metadata )	745✔
198	setMetadata( meta.first, meta.second );	375✔
199	}	370✔
200
201	std::string MDAL::DatasetGroup::name()	350✔
202	{
203	return getMetadata( "name" );	350✔
204	}
205
206	void MDAL::DatasetGroup::setName( const std::string &name )	992✔
207	{
208	setMetadata( "name", name );	992✔
209	}	992✔
210
211	std::string MDAL::DatasetGroup::uri() const	74✔
212	{
213	return mUri;	74✔
214	}
215
216	void MDAL::DatasetGroup::replaceUri( std::string uri )	×
217	{
218	mUri = uri;	×
219	}	×
220
221	MDAL::Statistics MDAL::DatasetGroup::statistics() const	56✔
222	{
223	return mStatistics;	56✔
224	}
225
226	void MDAL::DatasetGroup::setStatistics( const Statistics &statistics )	928✔
227	{
228	mStatistics = statistics;	928✔
229	}	928✔
230
231	MDAL::DateTime MDAL::DatasetGroup::referenceTime() const	141✔
232	{
233	return mReferenceTime;	141✔
234	}
235
236	void MDAL::DatasetGroup::setReferenceTime( const DateTime &referenceTime )	464✔
237	{
238	mReferenceTime = referenceTime;	464✔
239	}	464✔
240
241	MDAL::Mesh *MDAL::DatasetGroup::mesh() const	1,772,963✔
242	{
243	return mParent;	1,772,963✔
244	}
245
246	size_t MDAL::DatasetGroup::maximumVerticalLevelsCount() const	5✔
247	{
248	size_t maxLevels = 0;	5✔
249	for ( const std::shared_ptr<Dataset> &ds : datasets )	7✔
250	{
251	const size_t maxDsLevels = ds->maximumVerticalLevelsCount();	5✔
252	if ( maxDsLevels > maxLevels )	5✔
253	return maxLevels = maxDsLevels;	3✔
254	}
255	return maxLevels;	2✔
256	}
257
258	bool MDAL::DatasetGroup::isInEditMode() const	229✔
259	{
260	return mInEditMode;	229✔
261	}
262
263	void MDAL::DatasetGroup::startEditing()	35✔
264	{
265	mInEditMode = true;	35✔
266	}	35✔
267
268	void MDAL::DatasetGroup::stopEditing()	35✔
269	{
270	mInEditMode = false;	35✔
271	}	35✔
272
273	void MDAL::DatasetGroup::setReferenceAngles( const std::pair<double, double> &referenceAngle )	3✔
274	{
275	mReferenceAngles = referenceAngle;	3✔
276	}	3✔
277
278	bool MDAL::DatasetGroup::isPolar() const	577,361✔
279	{
280	return mIsPolar;	577,361✔
281	}
282
283	void MDAL::DatasetGroup::setIsPolar( bool isPolar )	370✔
284	{
285	mIsPolar = isPolar;	370✔
286	}	370✔
287
288	std::pair<double, double> MDAL::DatasetGroup::referenceAngles() const	1,927✔
289	{
290	return mReferenceAngles;	1,927✔
291	}
292
293	MDAL_DataLocation MDAL::DatasetGroup::dataLocation() const	1,790,697✔
294	{
295	return mDataLocation;	1,790,697✔
296	}
297
298	void MDAL::DatasetGroup::setDataLocation( MDAL_DataLocation dataLocation )	881✔
299	{
300	// datasets are initialized (e.g. values array, active array) based
301	// on this property. Do not allow to modify later on.
302	assert( datasets.empty() );	881✔
303	mDataLocation = dataLocation;	881✔
304	}	881✔
305
306	bool MDAL::DatasetGroup::isScalar() const	4,108,461✔
307	{
308	return mIsScalar;	4,108,461✔
309	}
310
311	void MDAL::DatasetGroup::setIsScalar( bool isScalar )	957✔
312	{
313	// datasets are initialized (e.g. values array, active array) based
314	// on this property. Do not allow to modify later on.
315	assert( datasets.empty() );	957✔
316	mIsScalar = isScalar;	957✔
317	}	957✔
318
319	MDAL::Mesh::Mesh( const std::string &driverName,	180✔
320	size_t faceVerticesMaximumCount,
321	const std::string &uri )	180✔
322	: mDriverName( driverName )	180✔
323	, mFaceVerticesMaximumCount( faceVerticesMaximumCount )	180✔
324	, mUri( uri )	360✔
325	{
326	}	180✔
327
328	std::string MDAL::Mesh::driverName() const	1,055✔
329	{
330	return mDriverName;	1,055✔
331	}
332
333	MDAL::Mesh::~Mesh() = default;	180✔
334
335	std::shared_ptr<MDAL::DatasetGroup> MDAL::Mesh::group( const std::string &name )	×
336	{
337	for ( auto grp : datasetGroups )	×
338	{
339	if ( grp->name() == name )	×
340	return grp;	×
341	}	×
342	return std::shared_ptr<MDAL::DatasetGroup>();	×
343	}
344
345	void MDAL::Mesh::setSourceCrs( const std::string &str )	57✔
346	{
347	mCrs = MDAL::trim( str );	57✔
348	}	57✔
349
350	void MDAL::Mesh::setSourceCrsFromWKT( const std::string &wkt )	19✔
351	{
352	setSourceCrs( wkt );	19✔
353	}	19✔
354
355	void MDAL::Mesh::setSourceCrsFromEPSG( int code )	×
356	{
357	setSourceCrs( std::string( "EPSG:" ) + std::to_string( code ) );	×
358	}	×
359
360	void MDAL::Mesh::setSourceCrsFromPrjFile( const std::string &filename )	6✔
361	{
362	const std::string proj = MDAL::readFileToString( filename );	6✔
363	setSourceCrs( proj );	6✔
364	}	6✔
365
366	std::string MDAL::Mesh::getMetadata( const std::string &key )	×
367	{
368	for ( auto &pair : metadata )	×
369	{
370	if ( pair.first == key )	×
371	{
372	return pair.second;	×
373	}
374	}
375	return std::string();	×
376	}
377
378	void MDAL::Mesh::setMetadata( const std::string &key, const std::string &val )	2✔
379	{
380	bool found = false;	2✔
381	for ( auto &pair : metadata )	3✔
382	{
383	if ( pair.first == key )	1✔
384	{
385	found = true;	1✔
386	pair.second = val;	1✔
387	}
388	}
389	if ( !found )	2✔
390	metadata.push_back( std::make_pair( key, val ) );	1✔
391	}	2✔
392
393	void MDAL::Mesh::setMetadata( const MDAL::Metadata &new_metadata )	×
394	{
395	for ( const auto &meta : new_metadata )	×
396	setMetadata( meta.first, meta.second );	×
397	}	×
398
399
400	std::string MDAL::Mesh::uri() const	212✔
401	{
402	return mUri;	212✔
403	}
404
405	std::string MDAL::Mesh::crs() const	52✔
406	{
407	return mCrs;	52✔
408	}
409
410	size_t MDAL::Mesh::faceVerticesMaximumCount() const	5,015✔
411	{
412	return mFaceVerticesMaximumCount;	5,015✔
413	}
414
415	void MDAL::Mesh::setFaceVerticesMaximumCount( const size_t &faceVerticesMaximumCount )	5✔
416	{
417	mFaceVerticesMaximumCount = faceVerticesMaximumCount;	5✔
418	}	5✔
419
420	void MDAL::Mesh::addVertices( size_t vertexCount, double *coordinates )	1✔
421	{
422	MDAL_UNUSED( vertexCount );
423	MDAL_UNUSED( coordinates );
424	}	1✔
425
426	void MDAL::Mesh::addFaces( size_t faceCount, size_t driverMaxVerticesPerFace, int faceSizes, int vertexIndices )	×
427	{
428	MDAL_UNUSED( faceCount );
429	MDAL_UNUSED( driverMaxVerticesPerFace );
430	MDAL_UNUSED( faceSizes );
431	MDAL_UNUSED( vertexIndices );
432	}	×
433
434	void MDAL::Mesh::addEdges( size_t edgeCount, int startVertexIndices, int endVertexIndices )	×
435	{
436	MDAL_UNUSED( edgeCount );
437	MDAL_UNUSED( startVertexIndices );
438	MDAL_UNUSED( endVertexIndices );
439	}	×
440
441
442	MDAL::MeshVertexIterator::~MeshVertexIterator() = default;	155✔
443
444	MDAL::MeshFaceIterator::~MeshFaceIterator() = default;	207✔
445
446	MDAL::MeshEdgeIterator::~MeshEdgeIterator() = default;	41✔

lutraconsulting / MDAL / 3748625157

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous