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

src/common/api/admire_types.hpp

@@ -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;

src/common/api/convert.cpp

@@ -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

src/common/api/convert.hpp

@@ -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

src/common/api/types.cpp

@@ -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)) {}