/src/bag/api/bag_layer.cpp

Source (jump to first uncovered line)

#include "bag_layer.h"
#include "bag_metadata.h"
#include "bag_private.h"
#include "bag_trackinglist.h"

#include <array>

namespace BAG {

//! Constructor.
/*!
\param dataset
    The BAG Dataset this layer belongs to.
\param descriptor
    The descriptor of this layer.
*/
Layer::Layer(
    Dataset& dataset,
    LayerDescriptor& descriptor)
    : m_pBagDataset(dataset.shared_from_this())
    , m_pLayerDescriptor(descriptor.shared_from_this())
{
}

//! Retrieve the BAG Dataset this layer belongs to.
/*!
\return
    The BAG Dataset this layer belongs to.
*/
std::weak_ptr<Dataset> Layer::getDataset() & noexcept
{
    return m_pBagDataset;
}

//! Retrieve the BAG Dataset this layer belongs to.
/*!
\return
    The BAG Dataset this layer belongs to.
*/
std::weak_ptr<const Dataset> Layer::getDataset() const & noexcept
{
    return m_pBagDataset;
}

//! Determine the type of data stored in the specified layer type.
/*!
\return
    The type of data stored in the specified layer type.
*/
DataType Layer::getDataType(LayerType layerType) noexcept
{
    switch (layerType)
    {
    case Elevation:  //[[fallthrough]];
    case Uncertainty:  //[[fallthrough]];
    case Hypothesis_Strength:  //[[fallthrough]];
    case Shoal_Elevation:  //[[fallthrough]];
    case Std_Dev:  //[[fallthrough]];
    case Average_Elevation:  //[[fallthrough]];
    case Nominal_Elevation:
        return DT_FLOAT32;
    case Num_Hypotheses:  //[[fallthrough]];
    case Num_Soundings:
        return DT_UINT32;
    case Surface_Correction:
    case Georef_Metadata:  //[[fallthrough]];
        return DT_COMPOUND;
    default:
        return DT_UNKNOWN_DATA_TYPE;
    }
}

//! Retrieve the layer's descriptor.
/*!
\return
    The layer's descriptor.
    Will never be nullptr.
*/
std::shared_ptr<LayerDescriptor> Layer::getDescriptor() & noexcept
{
    return m_pLayerDescriptor;
}

//! Retrieve the layer's descriptor.
/*!
\return
    The layer's descriptor.
    Will never be nullptr.
*/
std::shared_ptr<const LayerDescriptor> Layer::getDescriptor() const & noexcept
{
    return m_pLayerDescriptor;
}

//! Retrieve the size of the specified data type.
/*!
\param
    The type of data.

\return
    The size of the specified data type.
*/
uint8_t Layer::getElementSize(DataType type)
{
    switch (type)
    {
    case DT_FLOAT32:
        return sizeof(float);
    case DT_UINT32:
        return sizeof(uint32_t);
    case DT_UINT8:
        return sizeof(uint8_t);
    case DT_UINT16:
        return sizeof(uint16_t);
    case DT_UINT64:
        return sizeof(uint64_t);
    case DT_BOOLEAN:
        return sizeof(bool);
    case DT_STRING:
        return sizeof(char*);
    case DT_COMPOUND:  //[[fallthrough]]
    case DT_UNKNOWN_DATA_TYPE:  //[[fallthrough]]
    default:
        throw UnsupportedElementSize{};
    }
}

//! Retrieve the HDF5 path of the specified layer.
/*!
\param layerType
    The type of layer.
\param groupType
    The type of group.
    NODE or ELEVATION.

\return
    The HDF5 path to the specified layer and group types.
*/
std::string Layer::getInternalPath(
    LayerType layerType,
    GroupType groupType)
{
    if (groupType == NODE)
        return NODE_GROUP_PATH;

    if (groupType == ELEVATION)
        return ELEVATION_SOLUTION_GROUP_PATH;

    if (groupType != UNKNOWN_GROUP_TYPE)
        throw UnsupportedGroupType{};

    switch (layerType)
    {
    case Elevation:
        return ELEVATION_PATH;
    case Uncertainty:
        return UNCERTAINTY_PATH;
    case Hypothesis_Strength:
        return HYPOTHESIS_STRENGTH_PATH;
    case Num_Hypotheses:
        return NUM_HYPOTHESES_PATH;
    case Shoal_Elevation:
        return SHOAL_ELEVATION_PATH;
    case Std_Dev:
        return STANDARD_DEV_PATH;
    case Num_Soundings:
        return NUM_SOUNDINGS_PATH;
    case Average_Elevation:
        return AVERAGE_PATH;
    case Nominal_Elevation:
        return NOMINAL_ELEVATION_PATH;
    case Surface_Correction:
        return VERT_DATUM_CORR_PATH;
    case Georef_Metadata:  // [[fallthrough]];
    case UNKNOWN_LAYER_TYPE:  // [[fallthrough]];
    default:
        throw UnsupportedLayerType{};
    }
}

//! Read a section of data from this layer.
/*!
    Read data from this layer starting at rowStart, columnStart, and continue
    until rowEnd, columnEnd (inclusive).

\param rowStart
    The starting row.
\param columnStart
    The starting column.
\param rowEnd
    The ending row (inclusive).
\param columnEnd
    The ending column (inclusive).

\return
    The section of data specified by the rows and columns.
*/
UInt8Array Layer::read(
    uint32_t rowStart,
    uint32_t columnStart,
    uint32_t rowEnd,
    uint32_t columnEnd) const
{
    if (rowStart > rowEnd || columnStart > columnEnd)
        throw InvalidReadSize{};

    if (m_pBagDataset.expired())
        throw DatasetNotFound{};

    const auto pDataset = m_pBagDataset.lock();
    uint32_t numRows = 0, numColumns = 0;
    std::tie(numRows, numColumns) = pDataset->getDescriptor().getDims();

    if (columnEnd >= numColumns || rowEnd >= numRows)
        throw InvalidReadSize{};

    return this->readProxy(rowStart, columnStart, rowEnd, columnEnd);
}

//! Write a section of data to this layer.
/*!
    Write data to this layer starting at rowStart, columnStart, and continue
    until rowEnd, columnEnd (inclusive).

    After writing the data, write the attributes.

\param rowStart
    The starting row.
\param columnStart
    The starting column.
\param rowEnd
    The ending row (inclusive).
\param columnEnd
    The ending column (inclusive).
\param buffer
    The data to be written.
    It must contain at least (rowEnd - rowStart + 1) * (columnEnd - columnStart + 1) elements!
*/
void Layer::write(
    uint32_t rowStart,
    uint32_t columnStart,
    uint32_t rowEnd,
    uint32_t columnEnd,
    const uint8_t* buffer)
{
    if (m_pBagDataset.expired())
        throw DatasetNotFound{};

    if (rowStart > rowEnd || columnStart > columnEnd)
        throw InvalidWriteSize{};

    if (!buffer)
        throw InvalidBuffer{};

    this->writeProxy(rowStart, columnStart, rowEnd, columnEnd, buffer);
    this->writeAttributesProxy();
}

//! Write the attributes this layer contains to disk.
void Layer::writeAttributes() const
{
    if (m_pBagDataset.expired())
        throw DatasetNotFound{};

    this->writeAttributesProxy();
}

}  // namespace BAG


Coverage Report

Created: 2025-08-24 06:11

Line	Count	Source (jump to first uncovered line)
1
2		#include "bag_layer.h"
3		#include "bag_metadata.h"
4		#include "bag_private.h"
5		#include "bag_trackinglist.h"
6
7		#include <array>
8
9		namespace BAG {
10
11		//! Constructor.
12		/*!
13		\param dataset
14		The BAG Dataset this layer belongs to.
15		\param descriptor
16		The descriptor of this layer.
17		*/
18		Layer::Layer(
19		Dataset& dataset,
20		LayerDescriptor& descriptor)
21	222	: m_pBagDataset(dataset.shared_from_this())
22	222	, m_pLayerDescriptor(descriptor.shared_from_this())
23	222	{
24	222	}
25
26		//! Retrieve the BAG Dataset this layer belongs to.
27		/*!
28		\return
29		The BAG Dataset this layer belongs to.
30		*/
31		std::weak_ptr<Dataset> Layer::getDataset() & noexcept
32	0	{
33	0	return m_pBagDataset;
34	0	}
35
36		//! Retrieve the BAG Dataset this layer belongs to.
37		/*!
38		\return
39		The BAG Dataset this layer belongs to.
40		*/
41		std::weak_ptr<const Dataset> Layer::getDataset() const & noexcept
42	0	{
43	0	return m_pBagDataset;
44	0	}
45
46		//! Determine the type of data stored in the specified layer type.
47		/*!
48		\return
49		The type of data stored in the specified layer type.
50		*/
51		DataType Layer::getDataType(LayerType layerType) noexcept
52	153	{
53	153	switch (layerType)
54	153	{
55	116	case Elevation: //[[fallthrough]];
56	137	case Uncertainty: //[[fallthrough]];
57	137	case Hypothesis_Strength: //[[fallthrough]];
58	137	case Shoal_Elevation: //[[fallthrough]];
59	137	case Std_Dev: //[[fallthrough]];
60	137	case Average_Elevation: //[[fallthrough]];
61	153	case Nominal_Elevation:
62	153	return DT_FLOAT32;
63	0	case Num_Hypotheses: //[[fallthrough]];
64	0	case Num_Soundings:
65	0	return DT_UINT32;
66	0	case Surface_Correction:
67	0	case Georef_Metadata: //[[fallthrough]];
68	0	return DT_COMPOUND;
69	0	default:
70	0	return DT_UNKNOWN_DATA_TYPE;
71	153	}
72	153	}
73
74		//! Retrieve the layer's descriptor.
75		/*!
76		\return
77		The layer's descriptor.
78		Will never be nullptr.
79		*/
80		std::shared_ptr<LayerDescriptor> Layer::getDescriptor() & noexcept
81	259	{
82	259	return m_pLayerDescriptor;
83	259	}
84
85		//! Retrieve the layer's descriptor.
86		/*!
87		\return
88		The layer's descriptor.
89		Will never be nullptr.
90		*/
91		std::shared_ptr<const LayerDescriptor> Layer::getDescriptor() const & noexcept
92	42	{
93	42	return m_pLayerDescriptor;
94	42	}
95
96		//! Retrieve the size of the specified data type.
97		/*!
98		\param
99		The type of data.
100
101		\return
102		The size of the specified data type.
103		*/
104		uint8_t Layer::getElementSize(DataType type)
105	3.33k	{
106	3.33k	switch (type)
107	3.33k	{
108	1.09k	case DT_FLOAT32:
109	1.09k	return sizeof(float);
110	217	case DT_UINT32:
111	217	return sizeof(uint32_t);
112	0	case DT_UINT8:
113	0	return sizeof(uint8_t);
114	53	case DT_UINT16:
115	53	return sizeof(uint16_t);
116	0	case DT_UINT64:
117	0	return sizeof(uint64_t);
118	769	case DT_BOOLEAN:
119	769	return sizeof(bool);
120	1.19k	case DT_STRING:
121	1.19k	return sizeof(char*);
122	1	case DT_COMPOUND: //[[fallthrough]]
123	1	case DT_UNKNOWN_DATA_TYPE: //[[fallthrough]]
124	3	default:
125	3	throw UnsupportedElementSize{};
126	3.33k	}
127	3.33k	}
128
129		//! Retrieve the HDF5 path of the specified layer.
130		/*!
131		\param layerType
132		The type of layer.
133		\param groupType
134		The type of group.
135		NODE or ELEVATION.
136
137		\return
138		The HDF5 path to the specified layer and group types.
139		*/
140		std::string Layer::getInternalPath(
141		LayerType layerType,
142		GroupType groupType)
143	2.31k	{
144	2.31k	if (groupType == NODE)
145	0	return NODE_GROUP_PATH;
146
147	2.31k	if (groupType == ELEVATION)
148	0	return ELEVATION_SOLUTION_GROUP_PATH;
149
150	2.31k	if (groupType != UNKNOWN_GROUP_TYPE)
151	0	throw UnsupportedGroupType{};
152
153	2.31k	switch (layerType)
154	2.31k	{
155	351	case Elevation:
156	351	return ELEVATION_PATH;
157	256	case Uncertainty:
158	256	return UNCERTAINTY_PATH;
159	235	case Hypothesis_Strength:
160	235	return HYPOTHESIS_STRENGTH_PATH;
161	235	case Num_Hypotheses:
162	235	return NUM_HYPOTHESES_PATH;
163	235	case Shoal_Elevation:
164	235	return SHOAL_ELEVATION_PATH;
165	235	case Std_Dev:
166	235	return STANDARD_DEV_PATH;
167	235	case Num_Soundings:
168	235	return NUM_SOUNDINGS_PATH;
169	235	case Average_Elevation:
170	235	return AVERAGE_PATH;
171	251	case Nominal_Elevation:
172	251	return NOMINAL_ELEVATION_PATH;
173	48	case Surface_Correction:
174	48	return VERT_DATUM_CORR_PATH;
175	0	case Georef_Metadata: // [[fallthrough]];
176	0	case UNKNOWN_LAYER_TYPE: // [[fallthrough]];
177	0	default:
178	0	throw UnsupportedLayerType{};
179	2.31k	}
180	2.31k	}
181
182		//! Read a section of data from this layer.
183		/*!
184		Read data from this layer starting at rowStart, columnStart, and continue
185		until rowEnd, columnEnd (inclusive).
186
187		\param rowStart
188		The starting row.
189		\param columnStart
190		The starting column.
191		\param rowEnd
192		The ending row (inclusive).
193		\param columnEnd
194		The ending column (inclusive).
195
196		\return
197		The section of data specified by the rows and columns.
198		*/
199		UInt8Array Layer::read(
200		uint32_t rowStart,
201		uint32_t columnStart,
202		uint32_t rowEnd,
203		uint32_t columnEnd) const
204	0	{
205	0	if (rowStart > rowEnd \|\| columnStart > columnEnd)
206	0	throw InvalidReadSize{};
207
208	0	if (m_pBagDataset.expired())
209	0	throw DatasetNotFound{};
210
211	0	const auto pDataset = m_pBagDataset.lock();
212	0	uint32_t numRows = 0, numColumns = 0;
213	0	std::tie(numRows, numColumns) = pDataset->getDescriptor().getDims();
214
215	0	if (columnEnd >= numColumns \|\| rowEnd >= numRows)
216	0	throw InvalidReadSize{};
217
218	0	return this->readProxy(rowStart, columnStart, rowEnd, columnEnd);
219	0	}
220
221		//! Write a section of data to this layer.
222		/*!
223		Write data to this layer starting at rowStart, columnStart, and continue
224		until rowEnd, columnEnd (inclusive).
225
226		After writing the data, write the attributes.
227
228		\param rowStart
229		The starting row.
230		\param columnStart
231		The starting column.
232		\param rowEnd
233		The ending row (inclusive).
234		\param columnEnd
235		The ending column (inclusive).
236		\param buffer
237		The data to be written.
238		It must contain at least (rowEnd - rowStart + 1) * (columnEnd - columnStart + 1) elements!
239		*/
240		void Layer::write(
241		uint32_t rowStart,
242		uint32_t columnStart,
243		uint32_t rowEnd,
244		uint32_t columnEnd,
245		const uint8_t* buffer)
246	0	{
247	0	if (m_pBagDataset.expired())
248	0	throw DatasetNotFound{};
249
250	0	if (rowStart > rowEnd \|\| columnStart > columnEnd)
251	0	throw InvalidWriteSize{};
252
253	0	if (!buffer)
254	0	throw InvalidBuffer{};
255
256	0	this->writeProxy(rowStart, columnStart, rowEnd, columnEnd, buffer);
257	0	this->writeAttributesProxy();
258	0	}
259
260		//! Write the attributes this layer contains to disk.
261		void Layer::writeAttributes() const
262	0	{
263	0	if (m_pBagDataset.expired())
264	0	throw DatasetNotFound{};
265
266	0	this->writeAttributesProxy();
267	0	}
268
269		} // namespace BAG
270