Support optional entities in admire::qos::limit (7f248631) · Commits · eu / ADMIRE / scord

src/common/api/admire_types.hpp

+5 −3

Original line number	Diff line number	Diff line
		@@ -31,6 +31,7 @@
		#include <filesystem>
		#include <fmt/format.h>
		#include <utils/ctype_ptr.hpp>
		#include <optional>
		#include "admire_types.h"

		namespace admire {
		@@ -170,8 +171,9 @@ private:

		struct limit {

		limit(const admire::qos::entity& e, admire::qos::subclass cls,
		uint64_t value);
		limit(admire::qos::subclass cls, uint64_t value);
		limit(admire::qos::subclass cls, uint64_t value,
		const admire::qos::entity& e);
		explicit limit(ADM_qos_limit_t l);

		limit(const limit&) noexcept;
		@@ -183,7 +185,7 @@ struct limit {

		~limit();

		admire::qos::entity
		std::optional<admire::qos::entity>
		entity() const;

		admire::qos::subclass

src/common/api/convert.cpp

+35 −33

Original line number	Diff line number	Diff line
		@@ -181,41 +181,43 @@ convert(const std::vector<qos::limit>& limits) {
		[](const admire::qos::limit& l) {
		ADM_qos_entity_t e = nullptr;

		switch(l.entity().scope()) {
		if(l.entity()) {

		switch(const auto s = 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>())
		static_cast<ADM_qos_scope_t>(s),
		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>())
		static_cast<ADM_qos_scope_t>(s),
		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>())
		static_cast<ADM_qos_scope_t>(s),
		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>())
		static_cast<ADM_qos_scope_t>(s),
		convert(l.entity()
		->data<admire::transfer>())
		.release());
		break;
		}
		}
		}

		return ADM_qos_limit_create(
		e, static_cast<ADM_qos_class_t>(l.subclass()),

src/common/api/types.cpp

+19 −11

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@
		#include <cstdarg>
		#include <api/convert.hpp>
		#include <variant>
		#include <optional>
		#include "admire_types.hpp"

		/******************************************************************************/
		@@ -1451,13 +1452,17 @@ entity::data<admire::transfer>() const {
		class limit::impl {

		public:
		impl(admire::qos::entity e, admire::qos::subclass cls, uint64_t value)
		: m_entity(std::move(e)), m_subclass(cls), m_value(value) {}
		impl(admire::qos::subclass cls, uint64_t value, admire::qos::entity e)
		: m_subclass(cls), m_value(value), m_entity(std::move(e)) {}

		impl(admire::qos::subclass cls, uint64_t value)
		: 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) {}
		: m_subclass(static_cast<qos::subclass>(l->l_class)),
		m_value(l->l_value),
		m_entity(l->l_entity ? std::optional(admire::qos::entity(l->l_entity))
		: std::nullopt) {}

		impl(const impl& rhs) = default;
		impl(impl&& rhs) = default;
		@@ -1466,7 +1471,7 @@ public:
		impl&
		operator=(impl&&) noexcept = default;

		admire::qos::entity
		std::optional<admire::qos::entity>
		entity() const {
		return m_entity;
		}
		@@ -1482,14 +1487,17 @@ public:
		}

		private:
		admire::qos::entity m_entity;
		admire::qos::subclass m_subclass;
		uint64_t m_value;
		std::optional<admire::qos::entity> m_entity;
		};

		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(admire::qos::subclass cls, uint64_t value)
		: m_pimpl(std::make_unique<limit::impl>(cls, value)) {}

		limit::limit(admire::qos::subclass cls, uint64_t value,
		const admire::qos::entity& e)
		: m_pimpl(std::make_unique<limit::impl>(cls, value, e)) {}

		limit::limit(ADM_qos_limit_t l) : m_pimpl(std::make_unique<limit::impl>(l)) {}

		@@ -1509,7 +1517,7 @@ limit::operator=(limit&&) noexcept = default;

		limit::~limit() = default;

		admire::qos::entity
		std::optional<admire::qos::entity>
		limit::entity() const {
		return m_pimpl->entity();
		}