Skip to content
Snippets Groups Projects
Verified Commit 77beb5cf authored by Alberto Miranda's avatar Alberto Miranda :hotsprings:
Browse files

Add conversion functions for several API types

Conversion functions have been added for:
- admire::node
- admire::dataset
- std::vector<admire::qos::limit>
- ADM_transfer_t
- ADM_qos_limit_list_t
- ADM_dataset_list_t

Specializations for managed_ctype<T> and managed_ctype_array<T> have
been added for:
- ADM_node_t
- ADM_dataset_t
- ADM_qos_limit_t
- ADM_transfer_t
- ADM_qos_limit_list_t
- ADM_dataset_list_t
parent c7a6b1ea
No related branches found
No related tags found
1 merge request!30Resolve "Refactor library RPC implementation of `admire::transfer_dataset`"
......@@ -145,6 +145,7 @@ struct entity {
template <typename T>
entity(admire::qos::scope s, T&& data);
explicit entity(ADM_qos_entity_t entity);
entity(const entity&) noexcept;
entity(entity&&) noexcept;
......@@ -171,6 +172,7 @@ struct limit {
limit(const admire::qos::entity& e, admire::qos::subclass cls,
uint64_t value);
explicit limit(ADM_qos_limit_t l);
limit(const limit&) noexcept;
limit(limit&&) noexcept;
......
......@@ -23,6 +23,7 @@
*****************************************************************************/
#include <algorithm>
#include <net/proto/rpc_types.h>
#include "convert.hpp"
// forward declarations
......@@ -32,8 +33,30 @@ ADM_job_create(uint64_t id);
ADM_transfer_t
ADM_transfer_create(uint64_t id);
namespace {
admire::api::managed_ctype_array<ADM_dataset_t>
as_ctype_array(const std::vector<admire::dataset>& datasets) {
std::vector<ADM_dataset_t> tmp;
std::transform(datasets.cbegin(), datasets.cend(), std::back_inserter(tmp),
[](const admire::dataset& d) {
return ADM_dataset_create(d.id().c_str());
});
return admire::api::managed_ctype_array<ADM_dataset_t>{std::move(tmp)};
}
} // namespace
namespace admire::api {
managed_ctype<ADM_node_t>
convert(const node& node) {
return managed_ctype<ADM_node_t>(ADM_node_create(node.hostname().c_str()));
}
managed_ctype<ADM_adhoc_context_t>
convert(const adhoc_storage::ctx& ctx) {
return managed_ctype<ADM_adhoc_context_t>{ADM_adhoc_context_create(
......@@ -56,7 +79,13 @@ convert(const admire::adhoc_storage& st) {
return managed_ctype<ADM_storage_t>{c_st, std::move(managed_ctx)};
}
managed_ctype_array<ADM_dataset_t>
managed_ctype<ADM_dataset_t>
convert(const admire::dataset& dataset) {
return managed_ctype<ADM_dataset_t>(
ADM_dataset_create(dataset.id().c_str()));
}
managed_ctype<ADM_dataset_list_t>
convert(const std::vector<admire::dataset>& datasets) {
std::vector<ADM_dataset_t> tmp;
......@@ -66,7 +95,13 @@ convert(const std::vector<admire::dataset>& datasets) {
return ADM_dataset_create(d.id().c_str());
});
return managed_ctype_array<ADM_dataset_t>{std::move(tmp)};
auto rv = managed_ctype<ADM_dataset_list_t>{
ADM_dataset_list_create(tmp.data(), tmp.size())};
std::for_each(tmp.cbegin(), tmp.cend(),
[](ADM_dataset_t d) { ADM_dataset_destroy(d); });
return rv;
}
std::vector<admire::dataset>
......@@ -82,6 +117,19 @@ convert(ADM_dataset_t datasets[], size_t datasets_len) {
return rv;
}
std::vector<admire::dataset>
convert(ADM_dataset_list_t list) {
std::vector<admire::dataset> rv;
rv.reserve(list->l_length);
for(size_t i = 0; i < list->l_length; ++i) {
rv.emplace_back(&list->l_datasets[i]);
}
return rv;
}
managed_ctype<ADM_job_requirements_t>
convert(const admire::job_requirements& reqs) {
......@@ -89,8 +137,8 @@ convert(const admire::job_requirements& reqs) {
*std::dynamic_pointer_cast<admire::adhoc_storage>(reqs.storage());
auto managed_storage = convert(adhoc_storage);
auto managed_inputs = convert(reqs.inputs());
auto managed_outputs = convert(reqs.outputs());
auto managed_inputs = as_ctype_array(reqs.inputs());
auto managed_outputs = as_ctype_array(reqs.outputs());
ADM_job_requirements_t c_reqs = ADM_job_requirements_create(
managed_inputs.data(), managed_inputs.size(),
......@@ -118,4 +166,96 @@ convert(const transfer& tx) {
return managed_ctype<ADM_transfer_t>(ADM_transfer_create(tx.id()));
}
transfer
convert(ADM_transfer_t tx) {
return transfer{tx};
}
managed_ctype<ADM_qos_limit_list_t>
convert(const std::vector<qos::limit>& limits) {
std::vector<ADM_qos_limit_t> tmp;
std::transform(
limits.cbegin(), limits.cend(), std::back_inserter(tmp),
[](const admire::qos::limit& l) {
ADM_qos_entity_t e = nullptr;
switch(l.entity().scope()) {
case qos::scope::dataset: {
e = ADM_qos_entity_create(
static_cast<ADM_qos_scope_t>(
qos::scope::dataset),
convert(l.entity().data<admire::dataset>())
.release());
break;
}
case qos::scope::node: {
e = ADM_qos_entity_create(
static_cast<ADM_qos_scope_t>(qos::scope::node),
convert(l.entity().data<admire::node>())
.release());
break;
}
case qos::scope::job: {
e = ADM_qos_entity_create(
static_cast<ADM_qos_scope_t>(qos::scope::job),
convert(l.entity().data<admire::job>())
.release());
break;
}
case qos::scope::transfer: {
e = ADM_qos_entity_create(
static_cast<ADM_qos_scope_t>(
qos::scope::transfer),
convert(l.entity().data<admire::transfer>())
.release());
break;
}
}
return ADM_qos_limit_create(
e, static_cast<ADM_qos_class_t>(l.subclass()),
l.value());
});
auto rv = managed_ctype<ADM_qos_limit_list_t>{
ADM_qos_limit_list_create(tmp.data(), tmp.size())};
std::for_each(tmp.cbegin(), tmp.cend(),
[](ADM_qos_limit_t l) { ADM_qos_limit_destroy_all(l); });
return rv;
}
std::vector<qos::limit>
convert(ADM_qos_limit_t limits[], size_t limits_len) {
std::vector<admire::qos::limit> rv;
rv.reserve(limits_len);
for(size_t i = 0; i < limits_len; ++i) {
rv.emplace_back(limits[i]);
}
return rv;
}
std::vector<admire::qos::limit>
convert(ADM_qos_limit_list_t list) {
std::vector<admire::qos::limit> rv;
rv.reserve(list->l_length);
for(size_t i = 0; i < list->l_length; ++i) {
rv.emplace_back(&list->l_limits[i]);
}
return rv;
}
} // namespace admire::api
......@@ -39,18 +39,27 @@ struct managed_ctype_array;
// conversion functions between C API and CXX API types
managed_ctype<ADM_node_t>
convert(const node& node);
managed_ctype<ADM_adhoc_context_t>
convert(const adhoc_storage::ctx& ctx);
managed_ctype<ADM_storage_t>
convert(const admire::adhoc_storage& st);
managed_ctype_array<ADM_dataset_t>
managed_ctype<ADM_dataset_t>
convert(const admire::dataset& dataset);
managed_ctype<ADM_dataset_list_t>
convert(const std::vector<admire::dataset>& datasets);
std::vector<admire::dataset>
convert(ADM_dataset_t datasets[], size_t datasets_len);
std::vector<admire::dataset>
convert(ADM_dataset_list_t list);
managed_ctype<ADM_job_requirements_t>
convert(const admire::job_requirements& reqs);
......@@ -63,6 +72,17 @@ convert(ADM_job_t j);
managed_ctype<ADM_transfer_t>
convert(const transfer& t);
transfer
convert(ADM_transfer_t j);
managed_ctype<ADM_qos_limit_list_t>
convert(const std::vector<qos::limit>& limits);
std::vector<qos::limit>
convert(ADM_qos_limit_t limits[], size_t limits_len);
std::vector<admire::qos::limit>
convert(ADM_qos_limit_list_t list);
} // namespace admire::api
......@@ -71,6 +91,24 @@ convert(const transfer& t);
// Specializations for conversion types
////////////////////////////////////////////////////////////////////////////////
template <>
struct admire::api::managed_ctype<ADM_node_t> {
explicit managed_ctype(ADM_node_t node) : m_node(node) {}
ADM_node_t
get() const {
return m_node.get();
}
ADM_node_t
release() {
return m_node.release();
}
scord::utils::ctype_ptr<ADM_node_t, ADM_node_destroy> m_node;
};
template <>
struct admire::api::managed_ctype<ADM_adhoc_context_t> {
......@@ -111,6 +149,24 @@ struct admire::api::managed_ctype<ADM_storage_t> {
managed_ctype<ADM_adhoc_context_t> m_ctx;
};
template <>
struct admire::api::managed_ctype<ADM_dataset_t> {
explicit managed_ctype(ADM_dataset_t dataset) : m_dataset(dataset) {}
ADM_dataset_t
get() const {
return m_dataset.get();
}
ADM_dataset_t
release() {
return m_dataset.release();
}
scord::utils::ctype_ptr<ADM_dataset_t, ADM_dataset_destroy> m_dataset;
};
template <>
struct admire::api::managed_ctype_array<ADM_dataset_t> {
......@@ -144,6 +200,25 @@ struct admire::api::managed_ctype_array<ADM_dataset_t> {
m_datasets;
};
template <>
struct admire::api::managed_ctype<ADM_dataset_list_t> {
explicit managed_ctype(ADM_dataset_list_t list) : m_list(list) {}
ADM_dataset_list_t
get() const {
return m_list.get();
}
ADM_dataset_list_t
release() {
return m_list.release();
}
scord::utils::ctype_ptr<ADM_dataset_list_t, ADM_dataset_list_destroy>
m_list;
};
template <>
struct admire::api::managed_ctype<ADM_job_requirements_t> {
......@@ -217,5 +292,59 @@ struct admire::api::managed_ctype<ADM_transfer_t> {
scord::utils::ctype_ptr<ADM_transfer_t, ADM_transfer_destroy> m_transfer;
};
ADM_return_t
ADM_qos_limit_destroy_all(ADM_qos_limit_t l);
template <>
struct admire::api::managed_ctype_array<ADM_qos_limit_t> {
explicit managed_ctype_array(ADM_qos_limit_t data[], size_t size)
: m_qos_limits(data, size) {}
explicit managed_ctype_array(std::vector<ADM_qos_limit_t>&& v)
: m_qos_limits(v.data(), v.size()) {}
constexpr size_t
size() const {
return m_qos_limits.size();
}
constexpr const ADM_qos_limit_t*
data() const noexcept {
return m_qos_limits.data();
}
constexpr ADM_qos_limit_t*
data() noexcept {
return m_qos_limits.data();
}
constexpr ADM_qos_limit_t*
release() noexcept {
return m_qos_limits.release();
}
scord::utils::ctype_ptr_vector<ADM_qos_limit_t, ADM_qos_limit_destroy_all>
m_qos_limits;
};
template <>
struct admire::api::managed_ctype<ADM_qos_limit_list_t> {
explicit managed_ctype(ADM_qos_limit_list_t list) : m_list(list) {}
ADM_qos_limit_list_t
get() const {
return m_list.get();
}
ADM_qos_limit_list_t
release() {
return m_list.release();
}
scord::utils::ctype_ptr<ADM_qos_limit_list_t, ADM_qos_limit_list_destroy>
m_list;
};
#endif // SCORD_CONVERT_HPP
......@@ -1349,6 +1349,10 @@ public:
template <typename T>
impl(const admire::qos::scope& s, T&& data) : m_scope(s), m_data(data) {}
explicit impl(ADM_qos_entity_t entity)
: m_scope(static_cast<qos::scope>(entity->e_scope)),
m_data(init_helper(entity)) {}
impl(const impl& rhs) = default;
impl(impl&& rhs) = default;
impl&
......@@ -1367,6 +1371,25 @@ public:
return std::get<T>(m_data);
}
private:
static std::variant<dataset, node, job, transfer>
init_helper(ADM_qos_entity_t entity) {
switch(entity->e_scope) {
case ADM_QOS_SCOPE_DATASET:
return admire::dataset(entity->e_dataset);
case ADM_QOS_SCOPE_NODE:
return admire::node(entity->e_node);
case ADM_QOS_SCOPE_JOB:
return admire::job(entity->e_job);
case ADM_QOS_SCOPE_TRANSFER:
return admire::transfer(entity->e_transfer);
default:
throw std::runtime_error(fmt::format(
"Unexpected scope value: {}", entity->e_scope));
}
}
private:
admire::qos::scope m_scope;
std::variant<dataset, node, job, transfer> m_data;
......@@ -1376,6 +1399,9 @@ template <typename T>
entity::entity(admire::qos::scope s, T&& data)
: m_pimpl(std::make_unique<entity::impl>(s, std::forward<T>(data))) {}
entity::entity(ADM_qos_entity_t entity)
: m_pimpl(std::make_unique<entity::impl>(entity)) {}
entity::entity(const entity& other) noexcept
: m_pimpl(std::make_unique<entity::impl>(*other.m_pimpl)) {}
......@@ -1409,6 +1435,11 @@ public:
impl(admire::qos::entity e, admire::qos::subclass cls, uint64_t value)
: m_entity(std::move(e)), m_subclass(cls), m_value(value) {}
explicit impl(ADM_qos_limit_t l)
: m_entity(l->l_entity),
m_subclass(static_cast<qos::subclass>(l->l_class)),
m_value(l->l_value) {}
impl(const impl& rhs) = default;
impl(impl&& rhs) = default;
impl&
......@@ -1441,6 +1472,8 @@ limit::limit(const admire::qos::entity& e, admire::qos::subclass cls,
uint64_t value)
: m_pimpl(std::make_unique<limit::impl>(e, cls, value)) {}
limit::limit(ADM_qos_limit_t l) : m_pimpl(std::make_unique<limit::impl>(l)) {}
limit::limit(const limit& other) noexcept
: m_pimpl(std::make_unique<limit::impl>(*other.m_pimpl)) {}
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment