BlackMATov/meta.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/meta.hpp.git synced 2025-12-15 11:52:08 +07:00
Code Issues Packages Projects Releases Wiki Activity

cleanup metadata and arguments binding impl

Browse Source
This commit is contained in:
BlackMATov
2023-08-11 00:35:09 +07:00
parent 3ddd47b12e
commit 10a34a32a1
4 changed files with 386 additions and 426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

406
develop/singles/headers/meta.hpp/meta_all.hpp
View File

@@ -4516,50 +4516,6 @@ namespace meta_hpp::detail
&& std::is_same_v<Class, typename method_traits<Method>::class_type>; // && std::is_same_v<Class, typename method_traits<Method>::class_type>; //
} }
namespace meta_hpp
{
class argument_info final {
public:
argument_info() = default;
~argument_info() = default;
argument_info(argument_info&& other) = default;
argument_info& operator=(argument_info&&) = default;
argument_info(const argument_info&) = delete;
argument_info& operator=(const argument_info&) = delete;
argument_info(std::string name)
: name_{std::move(name)} {}
argument_info(std::string name, metadata_map metadata)
: name_{std::move(name)}
, metadata_{std::move(metadata)} {}
[[nodiscard]] std::string& get_name() {
return name_;
}
[[nodiscard]] const std::string& get_name() const {
return name_;
}
[[nodiscard]] metadata_map& get_metadata() {
return metadata_;
}
[[nodiscard]] const metadata_map& get_metadata() const {
return metadata_;
}
private:
std::string name_;
metadata_map metadata_;
};
using argument_info_list = std::vector<argument_info>;
}
namespace meta_hpp namespace meta_hpp
{ {
template < type_family Type > template < type_family Type >
@@ -4836,6 +4792,49 @@ namespace meta_hpp
namespace meta_hpp namespace meta_hpp
{ {
class arguments_bind final { class arguments_bind final {
public:
class argument_info final {
public:
argument_info() = default;
~argument_info() = default;
argument_info(argument_info&&) = default;
argument_info& operator=(argument_info&&) = default;
argument_info(const argument_info&) = delete;
argument_info& operator=(const argument_info&) = delete;
argument_info(std::string name)
: name_{std::move(name)} {}
argument_info(std::string name, metadata_map metadata)
: name_{std::move(name)}
, metadata_{std::move(metadata)} {}
[[nodiscard]] std::string& get_name() noexcept {
return name_;
}
[[nodiscard]] const std::string& get_name() const noexcept {
return name_;
}
[[nodiscard]] metadata_map& get_metadata() noexcept {
return metadata_;
}
[[nodiscard]] const metadata_map& get_metadata() const noexcept {
return metadata_;
}
private:
std::string name_;
metadata_map metadata_;
};
public:
using values_t = std::vector<argument_info>;
public: public:
arguments_bind() = default; arguments_bind() = default;
~arguments_bind() = default; ~arguments_bind() = default;
@@ -4847,31 +4846,67 @@ namespace meta_hpp
arguments_bind& operator=(const arguments_bind&) = delete; arguments_bind& operator=(const arguments_bind&) = delete;
arguments_bind& operator()(std::string name) & { arguments_bind& operator()(std::string name) & {
arguments_.emplace_back(std::move(name)); values_.emplace_back(std::move(name));
return *this; return *this;
} }
arguments_bind operator()(std::string name) && { arguments_bind operator()(std::string name) && {
arguments_.emplace_back(std::move(name)); values_.emplace_back(std::move(name));
return std::move(*this); return std::move(*this);
} }
arguments_bind& operator()(std::string name, metadata_map metadata) & { arguments_bind& operator()(std::string name, metadata_map metadata) & {
arguments_.emplace_back(std::move(name), std::move(metadata)); values_.emplace_back(std::move(name), std::move(metadata));
return *this; return *this;
} }
arguments_bind operator()(std::string name, metadata_map metadata) && { arguments_bind operator()(std::string name, metadata_map metadata) && {
arguments_.emplace_back(std::move(name), std::move(metadata)); values_.emplace_back(std::move(name), std::move(metadata));
return std::move(*this); return std::move(*this);
} }
operator argument_info_list() && { arguments_bind& operator()(values_t values) & {
return std::move(arguments_); values_.insert( //
values_.end(),
std::make_move_iterator(values.begin()),
std::make_move_iterator(values.end())
);
return *this;
}
arguments_bind operator()(values_t values) && {
values_.insert( //
values_.end(),
std::make_move_iterator(values.begin()),
std::make_move_iterator(values.end())
);
return std::move(*this);
}
arguments_bind& operator()(arguments_bind bind) & {
(*this)(std::move(bind.values_));
return *this;
}
arguments_bind operator()(arguments_bind bind) && {
(*this)(std::move(bind.values_));
return std::move(*this);
}
operator values_t() && {
return std::move(values_);
}
[[nodiscard]] values_t& get_values() noexcept {
return values_;
}
[[nodiscard]] const values_t& get_values() const noexcept {
return values_;
} }
private: private:
argument_info_list arguments_; values_t values_;
}; };
inline arguments_bind arguments_() { inline arguments_bind arguments_() {
@@ -4890,6 +4925,9 @@ namespace meta_hpp
namespace meta_hpp namespace meta_hpp
{ {
class metadata_bind final { class metadata_bind final {
public:
using values_t = metadata_map;
public: public:
metadata_bind() = default; metadata_bind() = default;
~metadata_bind() = default; ~metadata_bind() = default;
@@ -4901,21 +4939,49 @@ namespace meta_hpp
metadata_bind& operator=(const metadata_bind&) = delete; metadata_bind& operator=(const metadata_bind&) = delete;
metadata_bind& operator()(std::string name, uvalue value) & { metadata_bind& operator()(std::string name, uvalue value) & {
metadata_.insert_or_assign(std::move(name), std::move(value)); values_.insert_or_assign(std::move(name), std::move(value));
return *this; return *this;
} }
metadata_bind operator()(std::string name, uvalue value) && { metadata_bind operator()(std::string name, uvalue value) && {
metadata_.insert_or_assign(std::move(name), std::move(value)); values_.insert_or_assign(std::move(name), std::move(value));
return std::move(*this); return std::move(*this);
} }
operator metadata_map() && { metadata_bind& operator()(values_t values) & {
return std::move(metadata_); detail::insert_or_assign(values_, std::move(values));
return *this;
}
metadata_bind operator()(values_t values) && {
detail::insert_or_assign(values_, std::move(values));
return std::move(*this);
}
metadata_bind& operator()(metadata_bind bind) & {
(*this)(std::move(bind.values_));
return *this;
}
metadata_bind operator()(metadata_bind bind) && {
(*this)(std::move(bind.values_));
return std::move(*this);
}
operator values_t() && {
return std::move(values_);
}
[[nodiscard]] values_t& get_values() noexcept {
return values_;
}
[[nodiscard]] const values_t& get_values() const noexcept {
return values_;
} }
private: private:
metadata_map metadata_; values_t values_;
}; };
inline metadata_bind metadata_() { inline metadata_bind metadata_() {
@@ -5077,46 +5143,32 @@ namespace meta_hpp
"constructor policy may be specified only once" "constructor policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
argument_info_list arguments; arguments_bind arguments;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, constructor_policy::family auto) { [](constructor_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) { [&arguments](arguments_bind b) { arguments(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&arguments](arguments_bind::values_t vs) { arguments(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
[&arguments](auto&&, argument_info_list l) {
arguments.insert(arguments.end(),
std::make_move_iterator(l.begin()),
std::make_move_iterator(l.end()));
},
[](auto&& self, arguments_bind b) {
self(self, argument_info_list{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::constructor_state::make<policy_t, Class, Args...>(std::move(metadata)); auto state = detail::constructor_state::make<policy_t, Class, Args...>(std::move(metadata));
META_HPP_ASSERT( // META_HPP_ASSERT( //
arguments.size() <= state->arguments.size() // arguments.get_values().size() <= state->arguments.size() //
&& "provided argument names don't match constructor argument count" && "provided argument names don't match constructor argument count"
); );
for ( std::size_t i{}, e{std::min(arguments.size(), state->arguments.size())}; i < e; ++i ) { for ( std::size_t i{}, e{std::min(arguments.get_values().size(), state->arguments.size())}; i < e; ++i ) {
argument& arg = state->arguments[i]; argument& arg = state->arguments[i];
detail::state_access(arg)->name = std::move(arguments[i].get_name()); detail::state_access(arg)->name = std::move(arguments.get_values()[i].get_name());
detail::state_access(arg)->metadata = std::move(arguments[i].get_metadata()); detail::state_access(arg)->metadata = std::move(arguments.get_values()[i].get_metadata());
} }
detail::insert_or_assign(get_data().constructors, constructor{std::move(state)}); detail::insert_or_assign(get_data().constructors, constructor{std::move(state)});
@@ -5128,21 +5180,15 @@ namespace meta_hpp
class_bind<Class>& class_bind<Class>::destructor_(Opts&&... opts) class_bind<Class>& class_bind<Class>::destructor_(Opts&&... opts)
requires detail::class_bind_destructor_kind<Class> requires detail::class_bind_destructor_kind<Class>
{ {
metadata_map metadata; metadata_bind metadata;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[&metadata](auto&&, metadata_map m) { [&metadata](metadata_bind b) { metadata(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::destructor_state::make<Class>(std::move(metadata)); auto state = detail::destructor_state::make<Class>(std::move(metadata));
@@ -5161,46 +5207,32 @@ namespace meta_hpp
"function policy may be specified only once" "function policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
argument_info_list arguments; arguments_bind arguments;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, function_policy::family auto) { [](function_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) { [&arguments](arguments_bind b) { arguments(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&arguments](arguments_bind::values_t vs) { arguments(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
[&arguments](auto&&, argument_info_list l) {
arguments.insert(arguments.end(),
std::make_move_iterator(l.begin()),
std::make_move_iterator(l.end()));
},
[](auto&& self, arguments_bind b) {
self(self, argument_info_list{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::function_state::make<policy_t>(std::move(name), function_ptr, std::move(metadata)); auto state = detail::function_state::make<policy_t>(std::move(name), function_ptr, std::move(metadata));
META_HPP_ASSERT( // META_HPP_ASSERT( //
arguments.size() <= state->arguments.size() // arguments.get_values().size() <= state->arguments.size() //
&& "provided argument names don't match function argument count" && "provided argument names don't match function argument count"
); );
for ( std::size_t i{}, e{std::min(arguments.size(), state->arguments.size())}; i < e; ++i ) { for ( std::size_t i{}, e{std::min(arguments.get_values().size(), state->arguments.size())}; i < e; ++i ) {
argument& arg = state->arguments[i]; argument& arg = state->arguments[i];
detail::state_access(arg)->name = std::move(arguments[i].get_name()); detail::state_access(arg)->name = std::move(arguments.get_values()[i].get_name());
detail::state_access(arg)->metadata = std::move(arguments[i].get_metadata()); detail::state_access(arg)->metadata = std::move(arguments.get_values()[i].get_metadata());
} }
detail::insert_or_assign(get_data().functions, function{std::move(state)}); detail::insert_or_assign(get_data().functions, function{std::move(state)});
@@ -5218,24 +5250,16 @@ namespace meta_hpp
"member policy may be specified only once" "member policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, member_policy::family auto) { [](member_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) {
detail::insert_or_assign(metadata, std::move(m));
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::member_state::make<policy_t>(std::move(name), member_ptr, std::move(metadata)); auto state = detail::member_state::make<policy_t>(std::move(name), member_ptr, std::move(metadata));
@@ -5254,46 +5278,32 @@ namespace meta_hpp
"method policy may be specified only once" "method policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
argument_info_list arguments; arguments_bind arguments;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, method_policy::family auto) { [](method_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) { [&arguments](arguments_bind b) { arguments(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&arguments](arguments_bind::values_t vs) { arguments(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
[&arguments](auto&&, argument_info_list l) {
arguments.insert(arguments.end(),
std::make_move_iterator(l.begin()),
std::make_move_iterator(l.end()));
},
[](auto&& self, arguments_bind b) {
self(self, argument_info_list{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::method_state::make<policy_t>(std::move(name), method_ptr, std::move(metadata)); auto state = detail::method_state::make<policy_t>(std::move(name), method_ptr, std::move(metadata));
META_HPP_ASSERT( // META_HPP_ASSERT( //
arguments.size() <= state->arguments.size() // arguments.get_values().size() <= state->arguments.size() //
&& "provided argument names don't match method argument count" && "provided argument names don't match method argument count"
); );
for ( std::size_t i{}, e{std::min(arguments.size(), state->arguments.size())}; i < e; ++i ) { for ( std::size_t i{}, e{std::min(arguments.get_values().size(), state->arguments.size())}; i < e; ++i ) {
argument& arg = state->arguments[i]; argument& arg = state->arguments[i];
detail::state_access(arg)->name = std::move(arguments[i].get_name()); detail::state_access(arg)->name = std::move(arguments.get_values()[i].get_name());
detail::state_access(arg)->metadata = std::move(arguments[i].get_metadata()); detail::state_access(arg)->metadata = std::move(arguments.get_values()[i].get_metadata());
} }
detail::insert_or_assign(get_data().methods, method{std::move(state)}); detail::insert_or_assign(get_data().methods, method{std::move(state)});
@@ -5318,24 +5328,16 @@ namespace meta_hpp
"variable policy may be specified only once" "variable policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, variable_policy::family auto) { [](variable_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) {
detail::insert_or_assign(metadata, std::move(m));
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::variable_state::make<policy_t>(std::move(name), variable_ptr, std::move(metadata)); auto state = detail::variable_state::make<policy_t>(std::move(name), variable_ptr, std::move(metadata));
@@ -5440,46 +5442,32 @@ namespace meta_hpp
"function policy may be specified only once" "function policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
argument_info_list arguments; arguments_bind arguments;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, function_policy::family auto) { [](function_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) { [&arguments](arguments_bind b) { arguments(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&arguments](arguments_bind::values_t vs) { arguments(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
[&arguments](auto&&, argument_info_list l) {
arguments.insert(arguments.end(),
std::make_move_iterator(l.begin()),
std::make_move_iterator(l.end()));
},
[](auto&& self, arguments_bind b) {
self(self, argument_info_list{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::function_state::make<policy_t>(std::move(name), function_ptr, std::move(metadata)); auto state = detail::function_state::make<policy_t>(std::move(name), function_ptr, std::move(metadata));
META_HPP_ASSERT( // META_HPP_ASSERT( //
arguments.size() <= state->arguments.size() // arguments.get_values().size() <= state->arguments.size() //
&& "provided arguments don't match function argument count" && "provided arguments don't match function argument count"
); );
for ( std::size_t i{}, e{std::min(arguments.size(), state->arguments.size())}; i < e; ++i ) { for ( std::size_t i{}, e{std::min(arguments.get_values().size(), state->arguments.size())}; i < e; ++i ) {
argument& arg = state->arguments[i]; argument& arg = state->arguments[i];
detail::state_access(arg)->name = std::move(arguments[i].get_name()); detail::state_access(arg)->name = std::move(arguments.get_values()[i].get_name());
detail::state_access(arg)->metadata = std::move(arguments[i].get_metadata()); detail::state_access(arg)->metadata = std::move(arguments.get_values()[i].get_metadata());
} }
detail::insert_or_assign(get_state().functions, function{std::move(state)}); detail::insert_or_assign(get_state().functions, function{std::move(state)});
@@ -5502,24 +5490,16 @@ namespace meta_hpp
"variable policy may be specified only once" "variable policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, variable_policy::family auto) { [](variable_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) {
detail::insert_or_assign(metadata, std::move(m));
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::variable_state::make<policy_t>(std::move(name), variable_ptr, std::move(metadata)); auto state = detail::variable_state::make<policy_t>(std::move(name), variable_ptr, std::move(metadata));

178
headers/meta.hpp/meta_binds.hpp
View File

@@ -38,50 +38,6 @@ namespace meta_hpp::detail
&& std::is_same_v<Class, typename method_traits<Method>::class_type>; // && std::is_same_v<Class, typename method_traits<Method>::class_type>; //
} }
namespace meta_hpp
{
class argument_info final {
public:
argument_info() = default;
~argument_info() = default;
argument_info(argument_info&& other) = default;
argument_info& operator=(argument_info&&) = default;
argument_info(const argument_info&) = delete;
argument_info& operator=(const argument_info&) = delete;
argument_info(std::string name)
: name_{std::move(name)} {}
argument_info(std::string name, metadata_map metadata)
: name_{std::move(name)}
, metadata_{std::move(metadata)} {}
[[nodiscard]] std::string& get_name() {
return name_;
}
[[nodiscard]] const std::string& get_name() const {
return name_;
}
[[nodiscard]] metadata_map& get_metadata() {
return metadata_;
}
[[nodiscard]] const metadata_map& get_metadata() const {
return metadata_;
}
private:
std::string name_;
metadata_map metadata_;
};
using argument_info_list = std::vector<argument_info>;
}
namespace meta_hpp namespace meta_hpp
{ {
template < type_family Type > template < type_family Type >
@@ -358,6 +314,49 @@ namespace meta_hpp
namespace meta_hpp namespace meta_hpp
{ {
class arguments_bind final { class arguments_bind final {
public:
class argument_info final {
public:
argument_info() = default;
~argument_info() = default;
argument_info(argument_info&&) = default;
argument_info& operator=(argument_info&&) = default;
argument_info(const argument_info&) = delete;
argument_info& operator=(const argument_info&) = delete;
argument_info(std::string name)
: name_{std::move(name)} {}
argument_info(std::string name, metadata_map metadata)
: name_{std::move(name)}
, metadata_{std::move(metadata)} {}
[[nodiscard]] std::string& get_name() noexcept {
return name_;
}
[[nodiscard]] const std::string& get_name() const noexcept {
return name_;
}
[[nodiscard]] metadata_map& get_metadata() noexcept {
return metadata_;
}
[[nodiscard]] const metadata_map& get_metadata() const noexcept {
return metadata_;
}
private:
std::string name_;
metadata_map metadata_;
};
public:
using values_t = std::vector<argument_info>;
public: public:
arguments_bind() = default; arguments_bind() = default;
~arguments_bind() = default; ~arguments_bind() = default;
@@ -369,31 +368,67 @@ namespace meta_hpp
arguments_bind& operator=(const arguments_bind&) = delete; arguments_bind& operator=(const arguments_bind&) = delete;
arguments_bind& operator()(std::string name) & { arguments_bind& operator()(std::string name) & {
arguments_.emplace_back(std::move(name)); values_.emplace_back(std::move(name));
return *this; return *this;
} }
arguments_bind operator()(std::string name) && { arguments_bind operator()(std::string name) && {
arguments_.emplace_back(std::move(name)); values_.emplace_back(std::move(name));
return std::move(*this); return std::move(*this);
} }
arguments_bind& operator()(std::string name, metadata_map metadata) & { arguments_bind& operator()(std::string name, metadata_map metadata) & {
arguments_.emplace_back(std::move(name), std::move(metadata)); values_.emplace_back(std::move(name), std::move(metadata));
return *this; return *this;
} }
arguments_bind operator()(std::string name, metadata_map metadata) && { arguments_bind operator()(std::string name, metadata_map metadata) && {
arguments_.emplace_back(std::move(name), std::move(metadata)); values_.emplace_back(std::move(name), std::move(metadata));
return std::move(*this); return std::move(*this);
} }
operator argument_info_list() && { arguments_bind& operator()(values_t values) & {
return std::move(arguments_); values_.insert( //
values_.end(),
std::make_move_iterator(values.begin()),
std::make_move_iterator(values.end())
);
return *this;
}
arguments_bind operator()(values_t values) && {
values_.insert( //
values_.end(),
std::make_move_iterator(values.begin()),
std::make_move_iterator(values.end())
);
return std::move(*this);
}
arguments_bind& operator()(arguments_bind bind) & {
(*this)(std::move(bind.values_));
return *this;
}
arguments_bind operator()(arguments_bind bind) && {
(*this)(std::move(bind.values_));
return std::move(*this);
}
operator values_t() && {
return std::move(values_);
}
[[nodiscard]] values_t& get_values() noexcept {
return values_;
}
[[nodiscard]] const values_t& get_values() const noexcept {
return values_;
} }
private: private:
argument_info_list arguments_; values_t values_;
}; };
inline arguments_bind arguments_() { inline arguments_bind arguments_() {
@@ -412,6 +447,9 @@ namespace meta_hpp
namespace meta_hpp namespace meta_hpp
{ {
class metadata_bind final { class metadata_bind final {
public:
using values_t = metadata_map;
public: public:
metadata_bind() = default; metadata_bind() = default;
~metadata_bind() = default; ~metadata_bind() = default;
@@ -423,21 +461,49 @@ namespace meta_hpp
metadata_bind& operator=(const metadata_bind&) = delete; metadata_bind& operator=(const metadata_bind&) = delete;
metadata_bind& operator()(std::string name, uvalue value) & { metadata_bind& operator()(std::string name, uvalue value) & {
metadata_.insert_or_assign(std::move(name), std::move(value)); values_.insert_or_assign(std::move(name), std::move(value));
return *this; return *this;
} }
metadata_bind operator()(std::string name, uvalue value) && { metadata_bind operator()(std::string name, uvalue value) && {
metadata_.insert_or_assign(std::move(name), std::move(value)); values_.insert_or_assign(std::move(name), std::move(value));
return std::move(*this); return std::move(*this);
} }
operator metadata_map() && { metadata_bind& operator()(values_t values) & {
return std::move(metadata_); detail::insert_or_assign(values_, std::move(values));
return *this;
}
metadata_bind operator()(values_t values) && {
detail::insert_or_assign(values_, std::move(values));
return std::move(*this);
}
metadata_bind& operator()(metadata_bind bind) & {
(*this)(std::move(bind.values_));
return *this;
}
metadata_bind operator()(metadata_bind bind) && {
(*this)(std::move(bind.values_));
return std::move(*this);
}
operator values_t() && {
return std::move(values_);
}
[[nodiscard]] values_t& get_values() noexcept {
return values_;
}
[[nodiscard]] const values_t& get_values() const noexcept {
return values_;
} }
private: private:
metadata_map metadata_; values_t values_;
}; };
inline metadata_bind metadata_() { inline metadata_bind metadata_() {

170
headers/meta.hpp/meta_binds/class_bind.hpp
View File

@@ -153,46 +153,32 @@ namespace meta_hpp
"constructor policy may be specified only once" "constructor policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
argument_info_list arguments; arguments_bind arguments;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, constructor_policy::family auto) { [](constructor_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) { [&arguments](arguments_bind b) { arguments(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&arguments](arguments_bind::values_t vs) { arguments(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
[&arguments](auto&&, argument_info_list l) {
arguments.insert(arguments.end(),
std::make_move_iterator(l.begin()),
std::make_move_iterator(l.end()));
},
[](auto&& self, arguments_bind b) {
self(self, argument_info_list{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::constructor_state::make<policy_t, Class, Args...>(std::move(metadata)); auto state = detail::constructor_state::make<policy_t, Class, Args...>(std::move(metadata));
META_HPP_ASSERT( // META_HPP_ASSERT( //
arguments.size() <= state->arguments.size() // arguments.get_values().size() <= state->arguments.size() //
&& "provided argument names don't match constructor argument count" && "provided argument names don't match constructor argument count"
); );
for ( std::size_t i{}, e{std::min(arguments.size(), state->arguments.size())}; i < e; ++i ) { for ( std::size_t i{}, e{std::min(arguments.get_values().size(), state->arguments.size())}; i < e; ++i ) {
argument& arg = state->arguments[i]; argument& arg = state->arguments[i];
detail::state_access(arg)->name = std::move(arguments[i].get_name()); detail::state_access(arg)->name = std::move(arguments.get_values()[i].get_name());
detail::state_access(arg)->metadata = std::move(arguments[i].get_metadata()); detail::state_access(arg)->metadata = std::move(arguments.get_values()[i].get_metadata());
} }
detail::insert_or_assign(get_data().constructors, constructor{std::move(state)}); detail::insert_or_assign(get_data().constructors, constructor{std::move(state)});
@@ -204,21 +190,15 @@ namespace meta_hpp
class_bind<Class>& class_bind<Class>::destructor_(Opts&&... opts) class_bind<Class>& class_bind<Class>::destructor_(Opts&&... opts)
requires detail::class_bind_destructor_kind<Class> requires detail::class_bind_destructor_kind<Class>
{ {
metadata_map metadata; metadata_bind metadata;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[&metadata](auto&&, metadata_map m) { [&metadata](metadata_bind b) { metadata(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::destructor_state::make<Class>(std::move(metadata)); auto state = detail::destructor_state::make<Class>(std::move(metadata));
@@ -237,46 +217,32 @@ namespace meta_hpp
"function policy may be specified only once" "function policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
argument_info_list arguments; arguments_bind arguments;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, function_policy::family auto) { [](function_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) { [&arguments](arguments_bind b) { arguments(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&arguments](arguments_bind::values_t vs) { arguments(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
[&arguments](auto&&, argument_info_list l) {
arguments.insert(arguments.end(),
std::make_move_iterator(l.begin()),
std::make_move_iterator(l.end()));
},
[](auto&& self, arguments_bind b) {
self(self, argument_info_list{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::function_state::make<policy_t>(std::move(name), function_ptr, std::move(metadata)); auto state = detail::function_state::make<policy_t>(std::move(name), function_ptr, std::move(metadata));
META_HPP_ASSERT( // META_HPP_ASSERT( //
arguments.size() <= state->arguments.size() // arguments.get_values().size() <= state->arguments.size() //
&& "provided argument names don't match function argument count" && "provided argument names don't match function argument count"
); );
for ( std::size_t i{}, e{std::min(arguments.size(), state->arguments.size())}; i < e; ++i ) { for ( std::size_t i{}, e{std::min(arguments.get_values().size(), state->arguments.size())}; i < e; ++i ) {
argument& arg = state->arguments[i]; argument& arg = state->arguments[i];
detail::state_access(arg)->name = std::move(arguments[i].get_name()); detail::state_access(arg)->name = std::move(arguments.get_values()[i].get_name());
detail::state_access(arg)->metadata = std::move(arguments[i].get_metadata()); detail::state_access(arg)->metadata = std::move(arguments.get_values()[i].get_metadata());
} }
detail::insert_or_assign(get_data().functions, function{std::move(state)}); detail::insert_or_assign(get_data().functions, function{std::move(state)});
@@ -294,24 +260,16 @@ namespace meta_hpp
"member policy may be specified only once" "member policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, member_policy::family auto) { [](member_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) {
detail::insert_or_assign(metadata, std::move(m));
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::member_state::make<policy_t>(std::move(name), member_ptr, std::move(metadata)); auto state = detail::member_state::make<policy_t>(std::move(name), member_ptr, std::move(metadata));
@@ -330,46 +288,32 @@ namespace meta_hpp
"method policy may be specified only once" "method policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
argument_info_list arguments; arguments_bind arguments;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, method_policy::family auto) { [](method_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) { [&arguments](arguments_bind b) { arguments(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&arguments](arguments_bind::values_t vs) { arguments(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
[&arguments](auto&&, argument_info_list l) {
arguments.insert(arguments.end(),
std::make_move_iterator(l.begin()),
std::make_move_iterator(l.end()));
},
[](auto&& self, arguments_bind b) {
self(self, argument_info_list{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::method_state::make<policy_t>(std::move(name), method_ptr, std::move(metadata)); auto state = detail::method_state::make<policy_t>(std::move(name), method_ptr, std::move(metadata));
META_HPP_ASSERT( // META_HPP_ASSERT( //
arguments.size() <= state->arguments.size() // arguments.get_values().size() <= state->arguments.size() //
&& "provided argument names don't match method argument count" && "provided argument names don't match method argument count"
); );
for ( std::size_t i{}, e{std::min(arguments.size(), state->arguments.size())}; i < e; ++i ) { for ( std::size_t i{}, e{std::min(arguments.get_values().size(), state->arguments.size())}; i < e; ++i ) {
argument& arg = state->arguments[i]; argument& arg = state->arguments[i];
detail::state_access(arg)->name = std::move(arguments[i].get_name()); detail::state_access(arg)->name = std::move(arguments.get_values()[i].get_name());
detail::state_access(arg)->metadata = std::move(arguments[i].get_metadata()); detail::state_access(arg)->metadata = std::move(arguments.get_values()[i].get_metadata());
} }
detail::insert_or_assign(get_data().methods, method{std::move(state)}); detail::insert_or_assign(get_data().methods, method{std::move(state)});
@@ -394,24 +338,16 @@ namespace meta_hpp
"variable policy may be specified only once" "variable policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, variable_policy::family auto) { [](variable_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) {
detail::insert_or_assign(metadata, std::move(m));
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::variable_state::make<policy_t>(std::move(name), variable_ptr, std::move(metadata)); auto state = detail::variable_state::make<policy_t>(std::move(name), variable_ptr, std::move(metadata));

58
headers/meta.hpp/meta_binds/scope_bind.hpp
View File

@@ -25,46 +25,32 @@ namespace meta_hpp
"function policy may be specified only once" "function policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
argument_info_list arguments; arguments_bind arguments;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, function_policy::family auto) { [](function_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) { [&arguments](arguments_bind b) { arguments(std::move(b)); },
detail::insert_or_assign(metadata, std::move(m)); [&arguments](arguments_bind::values_t vs) { arguments(std::move(vs)); },
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
[&arguments](auto&&, argument_info_list l) {
arguments.insert(arguments.end(),
std::make_move_iterator(l.begin()),
std::make_move_iterator(l.end()));
},
[](auto&& self, arguments_bind b) {
self(self, argument_info_list{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::function_state::make<policy_t>(std::move(name), function_ptr, std::move(metadata)); auto state = detail::function_state::make<policy_t>(std::move(name), function_ptr, std::move(metadata));
META_HPP_ASSERT( // META_HPP_ASSERT( //
arguments.size() <= state->arguments.size() // arguments.get_values().size() <= state->arguments.size() //
&& "provided arguments don't match function argument count" && "provided arguments don't match function argument count"
); );
for ( std::size_t i{}, e{std::min(arguments.size(), state->arguments.size())}; i < e; ++i ) { for ( std::size_t i{}, e{std::min(arguments.get_values().size(), state->arguments.size())}; i < e; ++i ) {
argument& arg = state->arguments[i]; argument& arg = state->arguments[i];
detail::state_access(arg)->name = std::move(arguments[i].get_name()); detail::state_access(arg)->name = std::move(arguments.get_values()[i].get_name());
detail::state_access(arg)->metadata = std::move(arguments[i].get_metadata()); detail::state_access(arg)->metadata = std::move(arguments.get_values()[i].get_metadata());
} }
detail::insert_or_assign(get_state().functions, function{std::move(state)}); detail::insert_or_assign(get_state().functions, function{std::move(state)});
@@ -87,24 +73,16 @@ namespace meta_hpp
"variable policy may be specified only once" "variable policy may be specified only once"
); );
metadata_map metadata; metadata_bind metadata;
{ {
// clang-format off
const auto process_opt = detail::overloaded{ const auto process_opt = detail::overloaded{
[](auto&&, variable_policy::family auto) { [](variable_policy::family auto) {}, // nothing
// nothing [&metadata](metadata_bind b) { metadata(std::move(b)); },
}, [&metadata](metadata_bind::values_t vs) { metadata(std::move(vs)); },
[&metadata](auto&&, metadata_map m) {
detail::insert_or_assign(metadata, std::move(m));
},
[](auto&& self, metadata_bind b) {
self(self, metadata_map{std::move(b)});
},
}; };
// clang-format on
(process_opt(process_opt, std::forward<Opts>(opts)), ...); (process_opt(std::forward<Opts>(opts)), ...);
} }
auto state = detail::variable_state::make<policy_t>(std::move(name), variable_ptr, std::move(metadata)); auto state = detail::variable_state::make<policy_t>(std::move(name), variable_ptr, std::move(metadata));