BAG/api/bag_interleavedlegacylayerdescriptor.cpp at master · OpenNavigationSurface/BAG · GitHub

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

#include "bag_exceptions.h"
#include "bag_interleavedlegacylayer.h"
#include "bag_interleavedlegacylayerdescriptor.h"
#include "bag_private.h"


namespace BAG {

//! The constructor.
/*!
\param id
    The unique layer id.
\param layerType
    The type of layer to be read.
\param groupType
    The type of group to be read.
    NODE or ELEVATION.
*/
InterleavedLegacyLayerDescriptor::InterleavedLegacyLayerDescriptor(
    uint32_t id,
    LayerType layerType,
    GroupType groupType,
    uint32_t rows, uint32_t cols)
    : LayerDescriptor(id, Layer::getInternalPath(layerType),
        kLayerTypeMapString.at(layerType), layerType, rows, cols, 0, 0)
    , m_groupType(groupType)
    , m_elementSize(Layer::getElementSize(Layer::getDataType(layerType)))
{
    this->setInternalPath(groupType == NODE ?
        NODE_GROUP_PATH : ELEVATION_SOLUTION_GROUP_PATH);

    InterleavedLegacyLayerDescriptor::validateTypes(layerType, groupType);
}

//! The constructor.
/*!
\param dataset
    The BAG Dataset this layer belongs to.
\param layerType
    The type of layer to be read.
\param groupType
    The type of group to be read.
    NODE or ELEVATION.
*/
InterleavedLegacyLayerDescriptor::InterleavedLegacyLayerDescriptor(
    const Dataset& dataset,
    LayerType layerType,
    GroupType groupType,
    uint32_t rows, uint32_t cols)
    : LayerDescriptor(dataset, layerType,
        rows, cols,
        groupType == NODE
            ? NODE_GROUP_PATH
            : groupType == ELEVATION
                ? ELEVATION_SOLUTION_GROUP_PATH
                : "")
    , m_groupType(groupType)
    , m_elementSize(Layer::getElementSize(Layer::getDataType(layerType)))
{
    InterleavedLegacyLayerDescriptor::validateTypes(layerType, groupType);
}

//! Create an interleaved layer descriptor.
/*!
\param dataset
    The BAG Dataset this layer belongs to.
\param layerType
    The type of layer to be read.
\param groupType
    The type of group to be read.
    NODE or ELEVATION.

\return
    The newly created interleaved layer descriptor.
*/
std::shared_ptr<InterleavedLegacyLayerDescriptor> InterleavedLegacyLayerDescriptor::create(
    const Dataset& dataset,
    LayerType layerType,
    GroupType groupType)
{
    uint32_t rows, cols;
    std::tie(rows, cols) = dataset.getDescriptor().getDims();
    return std::shared_ptr<InterleavedLegacyLayerDescriptor>(
        new InterleavedLegacyLayerDescriptor{dataset.getNextId(), layerType,
            groupType, rows, cols});
}

//! Open an interleaved layer descriptor.
/*!
\param dataset
    The BAG Dataset this layer belongs to.
\param layerType
    The type of layer to be read.
\param groupType
    The type of group to be read.
    NODE or ELEVATION.

\return
    The newly opened interleaved layer descriptor.
*/
std::shared_ptr<InterleavedLegacyLayerDescriptor> InterleavedLegacyLayerDescriptor::open(
    const Dataset& dataset,
    LayerType layerType,
    GroupType groupType)
{
    uint32_t rows, cols;
    std::tie<uint32_t, uint32_t>(rows, cols) = dataset.getDescriptor().getDims();
    return std::shared_ptr<InterleavedLegacyLayerDescriptor>(
        new InterleavedLegacyLayerDescriptor{dataset, layerType, groupType, rows, cols});
}


//! \copydoc LayerDescriptor::getDataType
DataType InterleavedLegacyLayerDescriptor::getDataTypeProxy() const noexcept
{
    return Layer::getDataType(this->getLayerType());
}

//! \copydoc LayerDescriptor::getElementSize
uint8_t InterleavedLegacyLayerDescriptor::getElementSizeProxy() const noexcept
{
    return m_elementSize;
}

//! Return the group type of this layer.
/*!
\return
    The group type of this layer.
*/
GroupType InterleavedLegacyLayerDescriptor::getGroupType() const noexcept
{
    return m_groupType;
}

//! Verify the proper group and layer combination is given.
/*!
    Validate the specified layer type is allowed for the group type.  If the
    layer type is not valid for the specified group, an exception of type
    UnsupportedInterleavedLayer is thrown.

\param layerType
    The type of layer to be read.
\param groupType
    The type of group to be read.
    NODE or ELEVATION.
*/
void InterleavedLegacyLayerDescriptor::validateTypes(
    LayerType layerType,
    GroupType groupType)
{
    if (groupType == ELEVATION)
    {
        if (layerType != Shoal_Elevation && layerType != Std_Dev &&
            layerType != Num_Soundings)
            throw UnsupportedInterleavedLayer{};
    }
    else if (groupType == NODE)
    {
        if (layerType != Hypothesis_Strength && layerType != Num_Hypotheses)
            throw UnsupportedInterleavedLayer{};
    }
    else
        throw UnsupportedInterleavedLayer{};
}

}  // namespace BAG