Skip to content

Commit 373d19c

Browse files
jhollocjholloc
committed
tidying up code
1 parent 5357429 commit 373d19c

File tree

5 files changed

+166
-174
lines changed

5 files changed

+166
-174
lines changed

‎mapping_plugin/mapping_plugin.cpp‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -143,10 +143,12 @@ int JSONMappingPlugin::init(IDAM_PLUGIN_INTERFACE* plugin_interface)
143143
auto data_source = std::make_unique<json_plugin::UDADataSource>("UDA", "get", plugin_interface->pluginList, false);
144144
m_mapping_handler.register_data_source("UDA", std::move(data_source));
145145

146-
auto mastu_data_source = std::make_unique<json_plugin::UDADataSource>("CUSTOM_MASTU", "get", plugin_interface->pluginList, false);
146+
auto mastu_data_source =
147+
std::make_unique<json_plugin::UDADataSource>("CUSTOM_MASTU", "get", plugin_interface->pluginList, false);
147148
m_mapping_handler.register_data_source("CUSTOM_MASTU", std::move(mastu_data_source));
148149

149-
auto geom_data_source = std::make_unique<json_plugin::UDADataSource>("GEOMETRY", "get", plugin_interface->pluginList, false);
150+
auto geom_data_source =
151+
std::make_unique<json_plugin::UDADataSource>("GEOMETRY", "get", plugin_interface->pluginList, false);
150152
m_mapping_handler.register_data_source("GEOMETRY", std::move(geom_data_source));
151153

152154
m_init = true;

‎mapping_plugin/src/uda_data_source.cpp‎

Lines changed: 144 additions & 155 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@
1313

1414
// UDA includes
1515
#include <client/getEnvironment.h>
16+
#include <clientserver/compressDim.h>
1617
#include <clientserver/errorLog.h>
1718
#include <clientserver/initStructs.h>
1819
#include <clientserver/makeRequestBlock.h>
@@ -23,7 +24,6 @@
2324
#include <plugins/pluginStructs.h>
2425
#include <plugins/udaPlugin.h>
2526
#include <structures/struct.h>
26-
#include <clientserver/compressDim.h>
2727

2828
#include "map_types/data_source_mapping.hpp"
2929
#include "map_types/map_arguments.hpp"
@@ -53,7 +53,7 @@ std::string json_plugin::UDADataSource::get_request_str(const libtokamap::DataSo
5353
// string_stream << m_plugin_name << "::" << m_function.value_or("get") << "(";
5454
string_stream << m_plugin_name << "::";
5555

56-
if ( data_source_args.count("function") != 0 ) {
56+
if (data_source_args.count("function") != 0) {
5757
string_stream << data_source_args.at("function").get<std::string>();
5858
} else {
5959
string_stream << m_function.value_or("get");
@@ -137,164 +137,157 @@ int json_plugin::UDADataSource::call_plugins(DATA_BLOCK* data_block, const libto
137137

138138
namespace
139139
{
140-
class ArrayBuilder
140+
class ArrayBuilder
141+
{
142+
private:
143+
const char* m_data = nullptr;
144+
size_t m_size = {};
145+
std::vector<size_t> m_shape;
146+
int m_data_type = UDA_TYPE_UNKNOWN;
147+
bool m_owning = true;
148+
bool m_ownership_locked = false;
149+
bool m_buildable = false;
150+
bool m_free_data_required = false;
151+
152+
public:
153+
ArrayBuilder() = default;
154+
~ArrayBuilder()
141155
{
142-
private:
143-
const char* m_data = nullptr;
144-
size_t m_size = {};
145-
std::vector<size_t> m_shape;
146-
int m_data_type = UDA_TYPE_UNKNOWN;
147-
bool m_owning = true;
148-
bool m_ownership_locked = false;
149-
bool m_buildable = false;
150-
bool m_free_data_required = false;
151-
152-
public:
153-
ArrayBuilder() = default;
154-
~ArrayBuilder()
155-
{
156-
if (m_free_data_required and m_data != nullptr) {
157-
free(const_cast<char*>(m_data));
158-
}
156+
if (m_free_data_required and m_data != nullptr) {
157+
free(const_cast<char*>(m_data));
159158
}
159+
}
160160

161-
ArrayBuilder(const ArrayBuilder&) = delete;
162-
ArrayBuilder& operator=(const ArrayBuilder&) = delete;
163-
ArrayBuilder(ArrayBuilder&& other) = delete;
164-
ArrayBuilder& operator=(ArrayBuilder&& other) = delete;
165-
166-
enum class OwnershipPolicy
167-
{
168-
VIEW,
169-
COPY
170-
};
171-
172-
void set_ownership(OwnershipPolicy policy)
173-
{
174-
bool is_owning = (policy == OwnershipPolicy::COPY);
175-
if (m_ownership_locked and m_owning != is_owning) {
176-
throw std::runtime_error("Ownership policy already enforced by a previous option");
177-
}
178-
m_owning = is_owning;
179-
}
180-
ArrayBuilder& ownership(OwnershipPolicy policy)
181-
{
182-
set_ownership(policy);
183-
return *this;
184-
}
161+
ArrayBuilder(const ArrayBuilder&) = delete;
162+
ArrayBuilder& operator=(const ArrayBuilder&) = delete;
163+
ArrayBuilder(ArrayBuilder&& other) = delete;
164+
ArrayBuilder& operator=(ArrayBuilder&& other) = delete;
185165

186-
void set_data(const DATA_BLOCK& db)
187-
{
188-
m_data = db.data;
189-
m_size = db.data_n;
190-
m_shape.reserve(db.rank);
191-
for (int i = 0; i < db.rank; ++i) {
192-
m_shape.push_back(db.dims[i].dim_n);
193-
}
194-
m_data_type = db.data_type;
195-
m_buildable = true;
196-
}
197-
ArrayBuilder& data(const DATA_BLOCK& db)
198-
{
199-
set_data(db);
200-
return *this;
201-
}
202-
203-
void set_dimension_data(const DIMS& dim)
204-
{
205-
if (dim.compressed > 0) {
206-
DIMS tmp_dim = dim;
207-
208-
uncompressDim(&tmp_dim);
209-
tmp_dim.compressed = 0;
210-
tmp_dim.method = 0;
211-
212-
m_data = tmp_dim.dim;
213-
tmp_dim.dim = nullptr;
214-
m_free_data_required = true;
215-
216-
m_owning = true;
217-
m_ownership_locked = true; // cannot guarantee sufficient object lifetime?
218-
} else {
219-
m_data = dim.dim;
220-
}
221-
m_size = dim.dim_n;
222-
m_shape = {m_size};
223-
m_data_type = dim.data_type;
224-
m_buildable = true;
225-
}
226-
ArrayBuilder& dimension(const DIMS& dim)
227-
{
228-
set_dimension_data(dim);
229-
return *this;
230-
}
166+
enum class OwnershipPolicy { VIEW, COPY };
231167

232-
void set_time_data(const DATA_BLOCK& db)
233-
{
234-
auto index = db.order;
235-
if (index < 0 or index > db.rank or db.rank < 1) {
236-
throw std::runtime_error("No time data available for this signal");
237-
}
238-
set_dimension_data(db.dims[index]);
239-
}
240-
ArrayBuilder& time(const DATA_BLOCK& db)
241-
{
242-
set_time_data(db);
243-
return *this;
168+
void set_ownership(OwnershipPolicy policy)
169+
{
170+
bool is_owning = (policy == OwnershipPolicy::COPY);
171+
if (m_ownership_locked and m_owning != is_owning) {
172+
throw std::runtime_error("Ownership policy already enforced by a previous option");
244173
}
174+
m_owning = is_owning;
175+
}
176+
ArrayBuilder& ownership(OwnershipPolicy policy)
177+
{
178+
set_ownership(policy);
179+
return *this;
180+
}
245181

246-
private:
247-
template<typename T>
248-
libtokamap::TypedDataArray _array_factory()
249-
{
250-
return libtokamap::TypedDataArray(reinterpret_cast<T*>(const_cast<char*>(m_data)),
251-
m_size, std::move(m_shape), m_owning);
182+
void set_data(const DATA_BLOCK& db)
183+
{
184+
m_data = db.data;
185+
m_size = db.data_n;
186+
m_shape.reserve(db.rank);
187+
for (int i = 0; i < db.rank; ++i) {
188+
m_shape.push_back(db.dims[i].dim_n);
252189
}
253-
template<>
254-
libtokamap::TypedDataArray _array_factory<char>()
255-
{
256-
return libtokamap::TypedDataArray(const_cast<char*>(m_data), m_size, std::move(m_shape), m_owning);
190+
m_data_type = db.data_type;
191+
m_buildable = true;
192+
}
193+
ArrayBuilder& data(const DATA_BLOCK& db)
194+
{
195+
set_data(db);
196+
return *this;
197+
}
198+
199+
void set_dimension_data(const DIMS& dim)
200+
{
201+
if (dim.compressed > 0) {
202+
DIMS tmp_dim = dim;
203+
204+
uncompressDim(&tmp_dim);
205+
tmp_dim.compressed = 0;
206+
tmp_dim.method = 0;
207+
208+
m_data = tmp_dim.dim;
209+
tmp_dim.dim = nullptr;
210+
m_free_data_required = true;
211+
212+
m_owning = true;
213+
m_ownership_locked = true; // cannot guarantee sufficient object lifetime?
214+
} else {
215+
m_data = dim.dim;
257216
}
217+
m_size = dim.dim_n;
218+
m_shape = {m_size};
219+
m_data_type = dim.data_type;
220+
m_buildable = true;
221+
}
222+
ArrayBuilder& dimension(const DIMS& dim)
223+
{
224+
set_dimension_data(dim);
225+
return *this;
226+
}
258227

259-
public:
260-
libtokamap::TypedDataArray build()
261-
{
262-
switch (m_data_type) {
263-
case UDA_TYPE_SHORT:
264-
return _array_factory<short>();
265-
case UDA_TYPE_INT:
266-
return _array_factory<int>();
267-
case UDA_TYPE_UNSIGNED_INT:
268-
return _array_factory<short>();
269-
case UDA_TYPE_LONG:
270-
return _array_factory<long>();
271-
case UDA_TYPE_LONG64:
272-
return _array_factory<int64_t>();
273-
case UDA_TYPE_FLOAT:
274-
return _array_factory<float>();
275-
case UDA_TYPE_DOUBLE:
276-
return _array_factory<double>();
277-
case UDA_TYPE_UNSIGNED_CHAR:
278-
return _array_factory<unsigned char>();
279-
case UDA_TYPE_UNSIGNED_SHORT:
280-
return _array_factory<unsigned short>();
281-
case UDA_TYPE_UNSIGNED_LONG:
282-
return _array_factory<unsigned long>();
283-
case UDA_TYPE_UNSIGNED_LONG64:
284-
return _array_factory<uint64_t>();
285-
case UDA_TYPE_CHAR:
286-
case UDA_TYPE_STRING:
287-
return _array_factory<char>();
288-
case UDA_TYPE_COMPLEX:
289-
return _array_factory<COMPLEX>();
290-
case UDA_TYPE_DCOMPLEX:
291-
return _array_factory<DCOMPLEX>();
292-
default:
293-
throw std::runtime_error{"unknown data type"};
294-
}
228+
void set_time_data(const DATA_BLOCK& db)
229+
{
230+
auto index = db.order;
231+
if (index < 0 or index > db.rank or db.rank < 1) {
232+
throw std::runtime_error("No time data available for this signal");
295233
}
234+
set_dimension_data(db.dims[index]);
235+
}
236+
ArrayBuilder& time(const DATA_BLOCK& db)
237+
{
238+
set_time_data(db);
239+
return *this;
240+
}
296241

297-
};
242+
private:
243+
template <typename T> libtokamap::TypedDataArray _array_factory()
244+
{
245+
return libtokamap::TypedDataArray(reinterpret_cast<T*>(const_cast<char*>(m_data)), m_size, std::move(m_shape),
246+
m_owning);
247+
}
248+
template <> libtokamap::TypedDataArray _array_factory<char>()
249+
{
250+
return libtokamap::TypedDataArray(const_cast<char*>(m_data), m_size, std::move(m_shape), m_owning);
251+
}
252+
253+
public:
254+
libtokamap::TypedDataArray build()
255+
{
256+
switch (m_data_type) {
257+
case UDA_TYPE_SHORT:
258+
return _array_factory<short>();
259+
case UDA_TYPE_INT:
260+
return _array_factory<int>();
261+
case UDA_TYPE_UNSIGNED_INT:
262+
return _array_factory<short>();
263+
case UDA_TYPE_LONG:
264+
return _array_factory<long>();
265+
case UDA_TYPE_LONG64:
266+
return _array_factory<int64_t>();
267+
case UDA_TYPE_FLOAT:
268+
return _array_factory<float>();
269+
case UDA_TYPE_DOUBLE:
270+
return _array_factory<double>();
271+
case UDA_TYPE_UNSIGNED_CHAR:
272+
return _array_factory<unsigned char>();
273+
case UDA_TYPE_UNSIGNED_SHORT:
274+
return _array_factory<unsigned short>();
275+
case UDA_TYPE_UNSIGNED_LONG:
276+
return _array_factory<unsigned long>();
277+
case UDA_TYPE_UNSIGNED_LONG64:
278+
return _array_factory<uint64_t>();
279+
case UDA_TYPE_CHAR:
280+
case UDA_TYPE_STRING:
281+
return _array_factory<char>();
282+
case UDA_TYPE_COMPLEX:
283+
return _array_factory<COMPLEX>();
284+
case UDA_TYPE_DCOMPLEX:
285+
return _array_factory<DCOMPLEX>();
286+
default:
287+
throw std::runtime_error{"unknown data type"};
288+
}
289+
}
290+
};
298291
} // namespace
299292

300293
libtokamap::TypedDataArray json_plugin::UDADataSource::get(const libtokamap::DataSourceArgs& data_source_args,
@@ -308,12 +301,8 @@ libtokamap::TypedDataArray json_plugin::UDADataSource::get(const libtokamap::Dat
308301
return {};
309302
}
310303

311-
if (data_source_args.count("time") != 0 && data_source_args.at("time").get<bool>()){
312-
return ArrayBuilder().ownership(ArrayBuilder::OwnershipPolicy::COPY)
313-
.time(data_block)
314-
.build();
304+
if (data_source_args.count("time") != 0 && data_source_args.at("time").get<bool>()) {
305+
return ArrayBuilder().ownership(ArrayBuilder::OwnershipPolicy::COPY).time(data_block).build();
315306
}
316-
return ArrayBuilder().ownership(ArrayBuilder::OwnershipPolicy::COPY)
317-
.data(data_block)
318-
.build();
307+
return ArrayBuilder().ownership(ArrayBuilder::OwnershipPolicy::COPY).data(data_block).build();
319308
}

0 commit comments

Comments
 (0)