Verified Commit 77beb5cf authored by Alberto Miranda's avatar Alberto Miranda ♨️
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

src/common/api/admire_types.hpp

+2 −0
Original line number Diff line number Diff line
@@ -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

+144 −4
Original line number Diff line number Diff line
@@ -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

+130 −1
Original line number Diff line number Diff line
@@ -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

+33 −0
Original line number Diff line number Diff line
@@ -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)) {}