diff options
Diffstat (limited to 'include')
29 files changed, 1854 insertions, 0 deletions
diff --git a/include/yacppdic/auto_wirable.hpp b/include/yacppdic/auto_wirable.hpp new file mode 100644 index 0000000..09cef65 --- /dev/null +++ b/include/yacppdic/auto_wirable.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include "yacppdic/container.hpp" + +#include <memory> + +namespace yacppdic +{ + +template <class Interface, class ObjectImpl, class... Dependencies> +class AutoWirable +{ +public: + static auto resolve(const Container &container) noexcept + -> std::unique_ptr<Interface>; +}; + +} // namespace yacppdic + +#include "yacppdic/detail/auto_wirable-impl.hpp" diff --git a/include/yacppdic/concepts.hpp b/include/yacppdic/concepts.hpp new file mode 100644 index 0000000..d8097df --- /dev/null +++ b/include/yacppdic/concepts.hpp @@ -0,0 +1,16 @@ +#pragma once + +#include "yacppdic/type_traits.hpp" + +#include <type_traits> + +namespace yacppdic +{ + +template <typename Type> +concept Abstract = std::is_abstract_v<Type>; + +template <typename Type> +concept IsFactory = is_factory_v<Type>; + +} diff --git a/include/yacppdic/container.hpp b/include/yacppdic/container.hpp new file mode 100644 index 0000000..f8ffb90 --- /dev/null +++ b/include/yacppdic/container.hpp @@ -0,0 +1,65 @@ +#pragma once + +#include "yacppdic/interfaces/wrapper.hpp" + +#include "yacppdic/concepts.hpp" +#include "yacppdic/factory.hpp" +#include "yacppdic/object_type.hpp" + +#include <concepts> +#include <functional> +#include <memory> +#include <unordered_map> + +namespace yacppdic +{ + +class Container; + +template <typename Interface> +class BindingBuilder +{ +public: + explicit BindingBuilder(Container *container) noexcept; + + template <typename Impl> + requires Abstract<Interface> && std::derived_from<Impl, Interface> + void to() noexcept; + + template <typename FactoryFunc> + requires IsFactory<Interface> && std::constructible_from<Interface, FactoryFunc> + void to_factory(FactoryFunc factory) noexcept; + +private: + Container *_container; +}; + +class Container +{ +public: + Container() noexcept = default; + + template <typename Type> + using WrapperPtr = std::shared_ptr<Type>; + + template <class Interface> + auto bind() noexcept -> BindingBuilder<Interface>; + + template <class Interface> + requires Abstract<Interface> + auto get() const noexcept -> std::unique_ptr<Interface>; + + template <typename AFactory> + requires IsFactory<AFactory> + auto get() const noexcept -> AFactory; + + void add(BaseObjectType type, const WrapperPtr<IGenericWrapper> &wrapper) noexcept; + +private: + std::unordered_map<BaseObjectType, WrapperPtr<IGenericWrapper>, ObjectTypeHasher> + _bindings; +}; + +} // namespace yacppdic + +#include "yacppdic/detail/container-impl.hpp" diff --git a/include/yacppdic/detail/auto_wirable-impl.hpp b/include/yacppdic/detail/auto_wirable-impl.hpp new file mode 100644 index 0000000..e2dafa9 --- /dev/null +++ b/include/yacppdic/detail/auto_wirable-impl.hpp @@ -0,0 +1,16 @@ +#pragma once + +#include "yacppdic/auto_wirable.hpp" + +namespace yacppdic +{ + +template <class Interface, class ObjectImpl, class... Dependencies> +auto AutoWirable<Interface, ObjectImpl, Dependencies...>::resolve( + const Container &container +) noexcept -> std::unique_ptr<Interface> +{ + return std::make_unique<ObjectImpl>(container.get<Dependencies>()...); +} + +} // namespace yacppdic diff --git a/include/yacppdic/detail/container-impl.hpp b/include/yacppdic/detail/container-impl.hpp new file mode 100644 index 0000000..897b8c3 --- /dev/null +++ b/include/yacppdic/detail/container-impl.hpp @@ -0,0 +1,94 @@ +#pragma once + +#include "yacppdic/container.hpp" +#include "yacppdic/detail/internal/wrapper/function_wrapper.hpp" +#include "yacppdic/detail/internal/wrapper/object_wrapper.hpp" + +#include <iostream> + +namespace yacppdic +{ + +template <typename Interface> +BindingBuilder<Interface>::BindingBuilder(Container *container) noexcept + : _container(container) +{ +} + +template <typename Interface> +template <typename Impl> +requires Abstract<Interface> && std::derived_from<Impl, Interface> +void BindingBuilder<Interface>::to() noexcept +{ + using Wrapper = internal::ObjectWrapper<Interface, Impl>; + + auto wrapper = Container::WrapperPtr<Wrapper>(new Wrapper(*_container)); + + _container->add( + ObjectType<Interface>(), + std::dynamic_pointer_cast<IGenericWrapper>(wrapper) + ); +} + +template <typename Interface> +template <typename FactoryFunc> +requires IsFactory<Interface> && std::constructible_from<Interface, FactoryFunc> +void BindingBuilder<Interface>::to_factory(FactoryFunc factory) noexcept +{ + using Wrapper = internal::FunctionWrapper<Interface>; + + auto wrapper = Container::WrapperPtr<Wrapper>(new Wrapper(factory)); + + _container->add( + ObjectType<Interface>(), + std::dynamic_pointer_cast<IGenericWrapper>(wrapper) + ); +} + +template <typename Interface> +auto Container::bind() noexcept -> BindingBuilder<Interface> +{ + return BindingBuilder<Interface>(this); +} + +template <typename Interface> +requires Abstract<Interface> +auto Container::get() const noexcept -> std::unique_ptr<Interface> +{ + ObjectType<Interface> interface_type; + + if (_bindings.count(interface_type) == 0) + { + std::cerr + << "Error: Tried to get a item from the container using unbound interface '" + << interface_type.name() << "'" << std::endl; + exit(EXIT_FAILURE); + } + + auto wrapper = std::dynamic_pointer_cast<IWrapper<std::unique_ptr<Interface>>>( + _bindings.at(interface_type) + ); + + return wrapper->get(); +} + +template <typename AFactory> +requires IsFactory<AFactory> +auto Container::get() const noexcept -> AFactory +{ + auto wrapper = + std::dynamic_pointer_cast<IWrapper<AFactory>>(_bindings.at(ObjectType<AFactory>()) + ); + + return wrapper->get(); +} + +void Container::add( + BaseObjectType type, + const WrapperPtr<IGenericWrapper> &wrapper +) noexcept +{ + _bindings.insert({ type, wrapper }); +} + +} // namespace yacppdic diff --git a/include/yacppdic/detail/factory-impl.hpp b/include/yacppdic/detail/factory-impl.hpp new file mode 100644 index 0000000..3deede2 --- /dev/null +++ b/include/yacppdic/detail/factory-impl.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include "yacppdic/factory.hpp" + +namespace yacppdic +{ + +template <class Return, class... Args> +Factory<Return(Args...)>::Factory(const Factory &factory) : _functor(factory._functor) +{ +} + +template <class Return, class... Args> +Factory<Return(Args...)>::Factory(Factory &&factory) noexcept + : _functor(std::move(factory._functor)) +{ +} + +template <class Return, class... Args> +auto Factory<Return(Args...)>::operator=(Factory &&factory) noexcept + -> Factory<Return(Args...)> & +{ + _functor = std::move(factory._functor); + return *this; +} + +template <class Return, class... Args> +auto Factory<Return(Args...)>::operator=(std::nullptr_t) noexcept + -> Factory<Return(Args...)> & +{ + _functor = nullptr; + return *this; +} + +template <class Return, class... Args> +Factory<Return(Args...)>::~Factory() = default; + +template <class Return, class... Args> +Factory<Return(Args...)>::operator bool() const noexcept +{ + return static_cast<bool>(_functor); +} + +template <class Return, class... Args> +auto Factory<Return(Args...)>::operator()(Args... args) const -> Return +{ + return _functor(std::forward<Args>(args)...); +} + +template <class Return, class... Args> +auto Factory<Return(Args...)>::target_type() const noexcept -> const std::type_info & +{ + return _functor.target_type(); +} + +template <class Return, class... Args> +template <typename Tp> +auto Factory<Return(Args...)>::target() noexcept -> Tp * +{ + return static_cast<Tp *>(_functor.template target<Tp>()); +} + +template <class Return, class... Args> +template <typename Tp> +auto Factory<Return(Args...)>::target() const noexcept -> const Tp * +{ + return _functor.template target<Tp>(); +} + +} diff --git a/include/yacppdic/detail/internal/alloc_destructor-impl.hpp b/include/yacppdic/detail/internal/alloc_destructor-impl.hpp new file mode 100644 index 0000000..abcabba --- /dev/null +++ b/include/yacppdic/detail/internal/alloc_destructor-impl.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include "alloc_destructor.hpp" + +namespace yacppdic::internal +{ + +template <class Allocator> +AllocDestructor<Allocator>::AllocDestructor( + Allocator &allocator, + Size alloc_size +) noexcept + : _allocator(allocator), _size(alloc_size) +{ +} + +template <class Allocator> +void AllocDestructor<Allocator>::operator()(Pointer ptr) noexcept +{ + _alloc_traits::deallocate(_allocator, ptr, _size); +} + +} diff --git a/include/yacppdic/detail/internal/alloc_destructor.hpp b/include/yacppdic/detail/internal/alloc_destructor.hpp new file mode 100644 index 0000000..9160b8b --- /dev/null +++ b/include/yacppdic/detail/internal/alloc_destructor.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include <memory> + +namespace yacppdic::internal +{ + +template <class Traits, class Type> +struct RebindAllocHelper +{ + using type = typename Traits::template rebind_alloc<Type>; +}; + +template <class Allocator> +class AllocDestructor +{ + using _alloc_traits = std::allocator_traits<Allocator>; + +public: + using Pointer = typename _alloc_traits::pointer; + using Size = typename _alloc_traits::size_type; + + using pointer = Pointer; + using size = Size; + + AllocDestructor(Allocator &allocator, Size alloc_size) noexcept; + + void operator()(Pointer ptr) noexcept; + +private: + Allocator &_allocator; + Size _size; +}; + +} // namespace yacppdic::internal + +#include "alloc_destructor-impl.hpp" diff --git a/include/yacppdic/detail/internal/compressed_pair-impl.hpp b/include/yacppdic/detail/internal/compressed_pair-impl.hpp new file mode 100644 index 0000000..0e2a322 --- /dev/null +++ b/include/yacppdic/detail/internal/compressed_pair-impl.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include "compressed_pair.hpp" + +namespace yacppdic::internal +{ + +template <class Value, int Idx> +constexpr CompressedPairElement<Value, Idx>::CompressedPairElement( + DefaultInitTag /*default_init_tag*/ +) +{ +} + +template <class Value, int Idx> +constexpr CompressedPairElement<Value, Idx>::CompressedPairElement( + ValueInitTag /*value_init_tag*/ +) + : _value() +{ +} + +template <class Value, int Idx> +template <class... Args, size_t... Indices> +constexpr CompressedPairElement<Value, Idx>::CompressedPairElement( + std::piecewise_construct_t /*tag_types*/, + std::tuple<Args...> args, + TupleIndices<Indices...> /*indices*/ +) + : _value(std::forward<Args>(std::get<Indices>(args))...) +{ +} + +template <class Value, int Idx> +auto CompressedPairElement<Value, Idx>::get() noexcept -> ValueReference +{ + return _value; +} + +template <class Value, int Idx> +auto CompressedPairElement<Value, Idx>::get() const noexcept -> ConstValueReference +{ + return _value; +} + +} // namespace yacppdic::internal diff --git a/include/yacppdic/detail/internal/compressed_pair.hpp b/include/yacppdic/detail/internal/compressed_pair.hpp new file mode 100644 index 0000000..3c832c5 --- /dev/null +++ b/include/yacppdic/detail/internal/compressed_pair.hpp @@ -0,0 +1,199 @@ +#pragma once + +#include "yacppdic/detail/internal/misc_concepts.hpp" + +#include <concepts> +#include <tuple> +#include <type_traits> +#include <utility> + +namespace yacppdic::internal +{ + +// Tag used to default initialize one or both of the pair's elements. +struct DefaultInitTag +{ +}; + +struct ValueInitTag +{ +}; + +template <size_t...> +struct TupleIndices +{ +}; + +template <class IdxType, IdxType... Values> +struct IntegerSequence +{ + template <template <class OIdxType, OIdxType...> class ToIndexSeq, class ToIndexType> + using Convert = ToIndexSeq<ToIndexType, Values...>; + + template <size_t Sp> + using ToTupleIndices = TupleIndices<(Values + Sp)...>; +}; + +template <size_t SizeOne, size_t SizeTwo> +using MakeIndices = + typename __make_integer_seq<IntegerSequence, size_t, SizeOne - SizeTwo>:: + template ToTupleIndices<SizeTwo>; + +template <size_t SizeOne, size_t SizeTwo = 0> +requires(SizeTwo <= SizeOne) struct MakeTupleIndices +{ + using type = MakeIndices<SizeOne, SizeTwo>; +}; + +template <typename Value> +concept ValueCanBeEmptyBase = std::is_empty_v<Value> && !std::is_final_v<Value>; + +template <class Value, int Idx> +class CompressedPairElement +{ +public: + using ValueReference = Value &; + using ConstValueReference = const Value &; + + constexpr explicit CompressedPairElement(DefaultInitTag default_init_tag); + + constexpr explicit CompressedPairElement(ValueInitTag value_init_tag); + + template <class ElementValue> + requires std::same_as<CompressedPairElement, std::decay_t<ElementValue>> + // NOLINTNEXTLINE(bugprone-forwarding-reference-overload) + constexpr explicit CompressedPairElement(ElementValue &&value) + : _value(std::forward<ElementValue>(value)) + { + } + + template <class... Args, size_t... Indices> + constexpr CompressedPairElement( + std::piecewise_construct_t tag_type, + std::tuple<Args...> args, + TupleIndices<Indices...> tuple_indices + ); + + auto get() noexcept -> ValueReference; + + [[nodiscard]] auto get() const noexcept -> ConstValueReference; + +private: + Value _value; +}; + +template <class Value, int Idx> +requires ValueCanBeEmptyBase<Value> +struct CompressedPairElement<Value, Idx> : private Value +{ + using ValueReference = Value &; + using ConstValueReference = const Value &; + + constexpr CompressedPairElement() = default; + + constexpr explicit CompressedPairElement(DefaultInitTag /*unused*/) {} + + constexpr explicit CompressedPairElement(ValueInitTag /*unused*/) : Value() {} + + template <class ElementValue> + requires std::same_as<CompressedPairElement, typename std::decay<ElementValue>::type> + // NOLINTNEXTLINE(bugprone-forwarding-reference-overload) + constexpr explicit CompressedPairElement(ElementValue &&value) + : Value(std::forward<ElementValue>(value)) + { + } + + template <class... Args, size_t... Indices> + constexpr CompressedPairElement( + std::piecewise_construct_t /*unused*/, + std::tuple<Args...> args, + TupleIndices<Indices...> /*unused*/ + ) + : Value(std::forward<Args>(std::get<Indices>(args))...) + { + } + + auto get() noexcept -> ValueReference + { + return *this; + } + + [[nodiscard]] auto get() const noexcept -> ConstValueReference + { + return *this; + } +}; + +template <class ValueOne, class ValueTwo> +requires NotSameAs<ValueOne, ValueTwo> +class CompressedPair : private CompressedPairElement<ValueOne, 0>, + private CompressedPairElement<ValueTwo, 1> +{ +public: + using BaseOne = CompressedPairElement<ValueOne, 0>; + using BaseTwo = CompressedPairElement<ValueTwo, 1>; + + template <typename> + requires std::default_initializable<ValueOne> && std::default_initializable<ValueTwo> + constexpr CompressedPair() : BaseOne(ValueInitTag()), BaseTwo(ValueInitTag()) {} + + template <class FirstValue, class SecondValue> + constexpr CompressedPair(FirstValue &&first_value, SecondValue &&second_value) + : BaseOne(std::forward<FirstValue>(first_value)), + BaseTwo(std::forward<SecondValue>(second_value)) + { + } + + template <class... ArgsOne, class... ArgsTwo> + constexpr CompressedPair( + std::piecewise_construct_t piecewise_construct, + std::tuple<ArgsOne...> first_args, + std::tuple<ArgsTwo...> second_args + ) + : BaseOne( + piecewise_construct, + std::move(first_args), + typename MakeTupleIndices<sizeof...(ArgsOne)>::type() + ), + BaseTwo( + piecewise_construct, + std::move(second_args), + typename MakeTupleIndices<sizeof...(ArgsTwo)>::type() + ) + { + } + + auto first() noexcept -> typename BaseOne::ValueReference + { + return static_cast<BaseOne &>(*this).get(); + } + + [[nodiscard]] auto first() const noexcept -> typename BaseOne::ConstValueReference + { + return static_cast<BaseOne const &>(*this).get(); + } + + auto second() noexcept -> typename BaseTwo::ValueReference + { + return static_cast<BaseTwo &>(*this).get(); + } + + [[nodiscard]] auto second() const noexcept -> typename BaseTwo::ConstValueReference + { + return static_cast<BaseTwo const &>(*this).get(); + } + + constexpr static auto get_first_base(CompressedPair *pair) noexcept -> BaseOne * + { + return static_cast<BaseOne *>(pair); + } + + constexpr static auto get_second_base(CompressedPair *pair) noexcept -> BaseTwo * + { + return static_cast<BaseTwo *>(pair); + } +}; + +} // namespace yacppdic::internal + +#include "compressed_pair-impl.hpp" diff --git a/include/yacppdic/detail/internal/functor/alloc_functor-impl.hpp b/include/yacppdic/detail/internal/functor/alloc_functor-impl.hpp new file mode 100644 index 0000000..55de548 --- /dev/null +++ b/include/yacppdic/detail/internal/functor/alloc_functor-impl.hpp @@ -0,0 +1,186 @@ +#pragma once + +#include "alloc_functor.hpp" + +#include <functional> + +namespace yacppdic::internal +{ + +template <class Return> +template <class... Args> +auto InvokeReturnWrapper<Return>::call(Args &&...args) -> Return +{ + return std::invoke(std::forward<Args>(args)...); +} + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define ALLOC_FUNCTOR_TEMPLATE \ + template <class Function, class Allocator, class Return, class... Args> + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define ALLOC_FUNCTOR AllocFunctor<Function, Allocator, Return(Args...)> + +ALLOC_FUNCTOR_TEMPLATE +ALLOC_FUNCTOR::AllocFunctor(Target &&function) + : _function( + std::piecewise_construct, + std::forward_as_tuple(std::move(function)), + std::forward_as_tuple() + ) +{ +} + +ALLOC_FUNCTOR_TEMPLATE +ALLOC_FUNCTOR::AllocFunctor(const Target &function, const Alloc &allocator) + : _function( + std::piecewise_construct, + std::forward_as_tuple(function), + std::forward_as_tuple(allocator) + ) +{ +} + +ALLOC_FUNCTOR_TEMPLATE +ALLOC_FUNCTOR::AllocFunctor(const Target &function, Alloc &&allocator) + : _function( + std::piecewise_construct, + std::forward_as_tuple(function), + std::forward_as_tuple(std::move(allocator)) + ) +{ +} + +ALLOC_FUNCTOR_TEMPLATE +ALLOC_FUNCTOR::AllocFunctor(Target &&function, Alloc &&allocator) + : _function( + std::piecewise_construct, + std::forward_as_tuple(std::move(function)), + std::forward_as_tuple(std::move(allocator)) + ) +{ +} + +ALLOC_FUNCTOR_TEMPLATE +auto ALLOC_FUNCTOR::operator()(Args &&...args) -> Return +{ + using Invoker = InvokeReturnWrapper<Return>; + + return Invoker::call(_function.first(), std::forward<Args>(args)...); +} + +ALLOC_FUNCTOR_TEMPLATE +auto ALLOC_FUNCTOR::target() const -> const Target & +{ + return _function.first(); +} + +ALLOC_FUNCTOR_TEMPLATE +auto ALLOC_FUNCTOR::get_allocator() const -> const Alloc & +{ + return _function.second(); +} + +ALLOC_FUNCTOR_TEMPLATE +auto ALLOC_FUNCTOR::clone() const -> AllocFunctor * +{ + using AllocTraits = std::allocator_traits<Alloc>; + + using AllocHelper = typename RebindAllocHelper<AllocTraits, AllocFunctor>::type; + + auto alloc_helper = AllocHelper(_function.second()); + + using Destructor = AllocDestructor<AllocHelper>; + + auto hold = std::unique_ptr<AllocFunctor, Destructor>( + alloc_helper.allocate(1), + _Dp(alloc_helper, 1) + ); + + ::new (static_cast<void *>(hold.get())) + AllocFunctor(_function.first(), _Alloc(alloc_helper)); + + return hold.release(); +} + +ALLOC_FUNCTOR_TEMPLATE +void ALLOC_FUNCTOR::destroy() noexcept +{ + _function.~CompressedPair<Target, Alloc>(); +} + +ALLOC_FUNCTOR_TEMPLATE +void ALLOC_FUNCTOR::destroy_and_delete(AllocFunctor *functor) +{ + using AllocTraits = std::allocator_traits<Alloc>; + + using FunctorAlloc = typename RebindAllocHelper<AllocTraits, AllocFunctor>::type; + + auto functor_alloc = FunctorAlloc(functor->get_allocator()); + + functor->destroy(); + functor_alloc.deallocate(functor, 1); +} + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEFAULT_ALLOC_FUNCTOR_TEMPLATE \ + template <class Function, class Return, class... Args> + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define DEFAULT_ALLOC_FUNCTOR DefaultAllocFunctor<Function, Return(Args...)> + +DEFAULT_ALLOC_FUNCTOR_TEMPLATE +DEFAULT_ALLOC_FUNCTOR::DefaultAllocFunctor(Target &&function) + : _function(std::move(function)) +{ +} + +DEFAULT_ALLOC_FUNCTOR_TEMPLATE +DEFAULT_ALLOC_FUNCTOR::DefaultAllocFunctor(const Target &function) : _function(function) +{ +} + +DEFAULT_ALLOC_FUNCTOR_TEMPLATE +auto DEFAULT_ALLOC_FUNCTOR::operator()(Args &&...args) -> Return +{ + using Invoker = InvokeReturnWrapper<Return>; + + return Invoker::call(_function, std::forward<Args>(args)...); +} + +DEFAULT_ALLOC_FUNCTOR_TEMPLATE +auto DEFAULT_ALLOC_FUNCTOR::target() const -> const Target & +{ + return _function; +} + +DEFAULT_ALLOC_FUNCTOR_TEMPLATE +auto DEFAULT_ALLOC_FUNCTOR::clone() const -> DefaultAllocFunctor * +{ + std::allocator<DefaultAllocFunctor> allocator; + + DefaultAllocFunctor *functor_ptr = allocator.allocate(1); + + // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) + auto *res = ::new (static_cast<void *>(functor_ptr)) DefaultAllocFunctor(_function); + + return res; +} + +DEFAULT_ALLOC_FUNCTOR_TEMPLATE +void DEFAULT_ALLOC_FUNCTOR::destroy() noexcept +{ + _function.~_Target(); +} + +DEFAULT_ALLOC_FUNCTOR_TEMPLATE +void DEFAULT_ALLOC_FUNCTOR::destroy_and_delete(DefaultAllocFunctor *function) +{ + function->destroy(); + + std::allocator<DefaultAllocFunctor> allocator; + + allocator.deallocate(function, 1); +} + +} diff --git a/include/yacppdic/detail/internal/functor/alloc_functor.hpp b/include/yacppdic/detail/internal/functor/alloc_functor.hpp new file mode 100644 index 0000000..687f182 --- /dev/null +++ b/include/yacppdic/detail/internal/functor/alloc_functor.hpp @@ -0,0 +1,89 @@ +#pragma once + +#include "yacppdic/detail/internal/alloc_destructor.hpp" +#include "yacppdic/detail/internal/compressed_pair.hpp" + +#include <memory> +#include <type_traits> +#include <utility> + +namespace yacppdic::internal +{ + +template <typename Return> +struct InvokeReturnWrapper +{ + template <typename... Args> + static auto call(Args &&...args) -> Return; +}; + +/** + * Holds a functor and a allocator. + */ +template <class Function, class Allocator, class FunctionSignature> +class AllocFunctor; + +template <class Function, class Allocator, class Return, class... Args> +class AllocFunctor<Function, Allocator, Return(Args...)> +{ +public: + using Target = Function; + using Alloc = Allocator; + + explicit AllocFunctor(Target &&function); + + explicit AllocFunctor(const Target &function, const Alloc &allocator); + + explicit AllocFunctor(const Target &function, Alloc &&allocator); + + explicit AllocFunctor(Target &&function, Alloc &&allocator); + + auto operator()(Args &&...args) -> Return; + + [[nodiscard]] auto target() const -> const Target &; + + [[nodiscard]] auto get_allocator() const -> const Alloc &; + + [[nodiscard]] auto clone() const -> AllocFunctor *; + + void destroy() noexcept; + + static void destroy_and_delete(AllocFunctor *functor); + +private: + CompressedPair<Function, Allocator> _function; +}; + +/** + * Holds a functor and a allocator. + */ +template <class Function, class FB> +class DefaultAllocFunctor; + +template <class Function, class Return, class... Args> +class DefaultAllocFunctor<Function, Return(Args...)> +{ +public: + using Target = Function; + + explicit DefaultAllocFunctor(Target &&function); + + explicit DefaultAllocFunctor(const Target &function); + + auto operator()(Args &&...args) -> Return; + + auto target() const -> const Target &; + + auto clone() const -> DefaultAllocFunctor *; + + void destroy() noexcept; + + static void destroy_and_delete(DefaultAllocFunctor *function); + +private: + Function _function; +}; + +} // namespace yacppdic::internal + +#include "alloc_functor-impl.hpp" diff --git a/include/yacppdic/detail/internal/functor/copyable_functor-impl.hpp b/include/yacppdic/detail/internal/functor/copyable_functor-impl.hpp new file mode 100644 index 0000000..9c51492 --- /dev/null +++ b/include/yacppdic/detail/internal/functor/copyable_functor-impl.hpp @@ -0,0 +1,112 @@ +#pragma once + +#include "copyable_functor.hpp" + +#include <memory> +#include <utility> + +namespace yacppdic::internal +{ + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define COPYABLE_FUNCTOR_TEMPLATE \ + template <class Function, class Allocator, class Return, class... Args> + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define COPYABLE_FUNCTOR CopyableFunctor<Function, Allocator, Return(Args...)> + +COPYABLE_FUNCTOR_TEMPLATE +COPYABLE_FUNCTOR::CopyableFunctor(Function &&function) : _functor(std::move(function)) {} + +COPYABLE_FUNCTOR_TEMPLATE +COPYABLE_FUNCTOR::CopyableFunctor(const Function &function, const Allocator &allocator) + : _functor(function, allocator) +{ +} + +COPYABLE_FUNCTOR_TEMPLATE +COPYABLE_FUNCTOR::CopyableFunctor(const Function &function, Allocator &&allocator) + : _functor(function, std::move(allocator)) +{ +} + +COPYABLE_FUNCTOR_TEMPLATE +COPYABLE_FUNCTOR::CopyableFunctor(Function &&function, Allocator &&allocator) + : _functor(std::move(function), std::move(allocator)) +{ +} + +COPYABLE_FUNCTOR_TEMPLATE +auto COPYABLE_FUNCTOR::operator()(Args &&...args) -> Return +{ + return _functor(std::forward<Args>(args)...); +} + +COPYABLE_FUNCTOR_TEMPLATE +auto COPYABLE_FUNCTOR::clone() const -> ICopyableFunctor<Return(Args...)> * +{ + using AllocTraits = std::allocator_traits<Allocator>; + + using AllocHelper = typename RebindAllocHelper<AllocTraits, CopyableFunctor>::type; + + auto alloc_helper = AllocHelper(_functor.get_allocator()); + + using Destructor = AllocDestructor<AllocHelper>; + + auto hold = std::unique_ptr<CopyableFunctor, Destructor>( + alloc_helper.allocate(1), + Destructor(alloc_helper, 1) + ); + + ::new (static_cast<void *>(hold.get())) + CopyableFunctor(_functor.target(), Allocator(alloc_helper)); + + return hold.release(); +} + +COPYABLE_FUNCTOR_TEMPLATE +void COPYABLE_FUNCTOR::clone(ICopyableFunctor<Return(Args...)> *functor) const +{ + ::new (static_cast<void *>(functor)) + CopyableFunctor(_functor.target(), _functor.get_allocator()); +} + +COPYABLE_FUNCTOR_TEMPLATE +void COPYABLE_FUNCTOR::destroy() noexcept +{ + _functor.destroy(); +} + +COPYABLE_FUNCTOR_TEMPLATE +void COPYABLE_FUNCTOR::destroy_deallocate() noexcept +{ + using AllocTraits = std::allocator_traits<Allocator>; + + using AllocHelper = typename RebindAllocHelper<AllocTraits, CopyableFunctor>::type; + + auto alloc_helper = AllocHelper(_functor.get_allocator()); + + _functor.destroy(); + + alloc_helper.deallocate(this, 1); +} + +COPYABLE_FUNCTOR_TEMPLATE +auto COPYABLE_FUNCTOR::target(const std::type_info &type_info) const noexcept -> const + void * +{ + if (type_info == typeid(Function)) + { + return std::addressof(_functor.target()); + } + + return nullptr; +} + +COPYABLE_FUNCTOR_TEMPLATE +auto COPYABLE_FUNCTOR::target_type() const noexcept -> const std::type_info & +{ + return typeid(Function); +} + +} diff --git a/include/yacppdic/detail/internal/functor/copyable_functor.hpp b/include/yacppdic/detail/internal/functor/copyable_functor.hpp new file mode 100644 index 0000000..b305d38 --- /dev/null +++ b/include/yacppdic/detail/internal/functor/copyable_functor.hpp @@ -0,0 +1,52 @@ +#pragma once + +#include "yacppdic/detail/internal/interfaces/copyable_functor.hpp" + +#include "yacppdic/detail/internal/functor/alloc_functor.hpp" + +#include <typeinfo> + +namespace yacppdic::internal +{ + +/** + * A copyable function object. + */ +template <class Function, class Allocator, class FunctionSignature> +class CopyableFunctor; + +template <class Function, class Allocator, class Return, class... Args> +class CopyableFunctor<Function, Allocator, Return(Args...)> + : public ICopyableFunctor<Return(Args...)> +{ +public: + explicit CopyableFunctor(Function &&function); + + explicit CopyableFunctor(const Function &function, const Allocator &allocator); + + explicit CopyableFunctor(const Function &function, Allocator &&allocator); + + explicit CopyableFunctor(Function &&function, Allocator &&allocator); + + auto operator()(Args &&...args) -> Return override; + + auto clone() const -> ICopyableFunctor<Return(Args...)> * override; + + void clone(ICopyableFunctor<Return(Args...)> *functor) const override; + + void destroy() noexcept override; + + void destroy_deallocate() noexcept override; + + [[nodiscard]] auto target(const std::type_info &type_info) const noexcept -> const + void * override; + + [[nodiscard]] auto target_type() const noexcept -> const std::type_info & override; + +private: + AllocFunctor<Function, Allocator, Return(Args...)> _functor; +}; + +} // namespace yacppdic::internal + +#include "copyable_functor-impl.hpp" diff --git a/include/yacppdic/detail/internal/functor/value_functor-impl.hpp b/include/yacppdic/detail/internal/functor/value_functor-impl.hpp new file mode 100644 index 0000000..c1030aa --- /dev/null +++ b/include/yacppdic/detail/internal/functor/value_functor-impl.hpp @@ -0,0 +1,196 @@ +#pragma once + +#include "value_functor.hpp" + +namespace yacppdic::internal +{ + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define VALUE_FUNCTOR_TEMPLATE template <class Return, class... Args> + +// NOLINTNEXTLINE(cppcoreguidelines-macro-usage) +#define VALUE_FUNCTOR ValueFunctor<Return(Args...)> + +VALUE_FUNCTOR_TEMPLATE +VALUE_FUNCTOR::ValueFunctor() noexcept : _functor(nullptr) {} + +VALUE_FUNCTOR_TEMPLATE +template <class Function, class Allocator> +VALUE_FUNCTOR::ValueFunctor(Function &&function, const Allocator &allocator) + : _functor(nullptr) +{ + using AllocTraits = std::allocator_traits<Allocator>; + + using Functor = CopyableFunctor<Function, Allocator, Return(Args...)>; + + using FunctorAlloc = typename RebindAllocHelper<AllocTraits, Functor>::type; + + if (not_null(function)) + { + auto functor_alloc = FunctorAlloc(allocator); + + if (sizeof(Functor) <= sizeof(_buf) && + std::is_nothrow_copy_constructible<Function>::value && + std::is_nothrow_copy_constructible<FunctorAlloc>::value) + { + // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) + _functor = ::new (static_cast<void *>(&_buf)) + Functor(std::forward<Function>(function), Allocator(functor_alloc)); + } + else + { + using Destructor = AllocDestructor<FunctorAlloc>; + + auto hold = std::unique_ptr<TargetFunctor, Destructor>( + functor_alloc.allocate(1), + Destructor(functor_alloc, 1) + ); + + ::new (static_cast<void *>(hold.get())) + Functor(std::forward<Function>(function), Allocator(allocator)); + + _functor = hold.release(); + } + } +} + +VALUE_FUNCTOR_TEMPLATE +VALUE_FUNCTOR::ValueFunctor(const ValueFunctor &val_functor) +{ + if (val_functor._functor == nullptr) + { + _functor = nullptr; + } + else if (static_cast<void *>(val_functor._functor) == &val_functor._buf) + { + _functor = _as_copyable_functor(&_buf); + val_functor._functor->clone(_functor); + } + else + { + _functor = val_functor._functor->clone(); + } +} + +VALUE_FUNCTOR_TEMPLATE +VALUE_FUNCTOR::ValueFunctor(ValueFunctor &&val_functor) noexcept +{ + if (val_functor._functor == nullptr) + { + _functor = nullptr; + } + else if (static_cast<void *>(val_functor._functor) == &val_functor._buf) + { + _functor = _as_copyable_functor(&_buf); + val_functor._functor->clone(_functor); + } + else + { + _functor = val_functor._functor; + val_functor._functor = nullptr; + } +} + +VALUE_FUNCTOR_TEMPLATE +VALUE_FUNCTOR::~ValueFunctor() +{ + if (static_cast<void *>(_functor) == &_buf) + { + _functor->destroy(); + } + else if (_functor) + { + _functor->destroy_deallocate(); + } +} + +VALUE_FUNCTOR_TEMPLATE +auto VALUE_FUNCTOR::operator=(ValueFunctor &&val_functor) noexcept -> ValueFunctor & +{ + *this = nullptr; + + if (val_functor._functor == nullptr) + { + _functor = nullptr; + } + else if (static_cast<void *>(val_functor._functor) == &val_functor._buf) + { + _functor = _as_copyable_functor(&_buf); + val_functor._functor->clone(_functor); + } + else + { + _functor = val_functor._functor; + val_functor._functor = nullptr; + } + + return *this; +} + +VALUE_FUNCTOR_TEMPLATE +auto VALUE_FUNCTOR::operator=(std::nullptr_t) -> ValueFunctor & +{ + TargetFunctor *old_functor = _functor; + + _functor = nullptr; + + if (static_cast<void *>(old_functor) == &_buf) + { + old_functor->destroy(); + } + else if (old_functor) + { + old_functor->destroy_deallocate(); + } + + return *this; +} + +VALUE_FUNCTOR_TEMPLATE +auto VALUE_FUNCTOR::operator()(Args &&...args) const -> Return +{ + if (_functor == nullptr) + { + std::abort(); + } + + return (*_functor)(std::forward<Args>(args)...); +} + +VALUE_FUNCTOR_TEMPLATE +VALUE_FUNCTOR::operator bool() const noexcept +{ + return _functor != nullptr; +} + +VALUE_FUNCTOR_TEMPLATE +auto VALUE_FUNCTOR::target_type() const noexcept -> const std::type_info & +{ + if (_functor == nullptr) + { + return typeid(void); + } + + return _functor->target_type(); +} + +VALUE_FUNCTOR_TEMPLATE +template <typename Target> +auto VALUE_FUNCTOR::target() const noexcept -> const Target * +{ + if (_functor == nullptr) + { + return nullptr; + } + + return static_cast<const Target *>(_functor->target(typeid(Target))); +} + +VALUE_FUNCTOR_TEMPLATE +auto VALUE_FUNCTOR::_as_copyable_functor(void *function_ptr) -> TargetFunctor * +{ + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) + return reinterpret_cast<TargetFunctor *>(function_ptr); +} + +} diff --git a/include/yacppdic/detail/internal/functor/value_functor.hpp b/include/yacppdic/detail/internal/functor/value_functor.hpp new file mode 100644 index 0000000..e5cde97 --- /dev/null +++ b/include/yacppdic/detail/internal/functor/value_functor.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include "yacppdic/detail/internal/interfaces/copyable_functor.hpp" + +#include "yacppdic/detail/internal/functor/copyable_functor.hpp" +#include "yacppdic/detail/internal/misc_concepts.hpp" + +#include <memory> +#include <type_traits> + +namespace yacppdic::internal +{ + +/** + * Creates a value-type from a copyable functor. + */ +template <class Function> +class ValueFunctor; + +template <class Return, class... Args> +class ValueFunctor<Return(Args...)> +{ + using TargetFunctor = ICopyableFunctor<Return(Args...)>; + +public: + ValueFunctor() noexcept; + + template <class Function> + requires NotSameAs<std::decay_t<Function>, ValueFunctor> + // NOLINTNEXTLINE(bugprone-forwarding-reference-overload) + explicit ValueFunctor(Function &&function) + : ValueFunctor(std::forward<Function>(function), std::allocator<Function>()) + { + } + + template <class Function, class Allocator> + ValueFunctor(Function &&function, const Allocator &allocator); + + ValueFunctor(const ValueFunctor &val_functor); + + ValueFunctor(ValueFunctor &&val_functor) noexcept; + + ~ValueFunctor(); + + auto operator=(const ValueFunctor &val_functor) noexcept = delete; + + auto operator=(ValueFunctor &&val_functor) noexcept -> ValueFunctor &; + + auto operator=(std::nullptr_t) -> ValueFunctor &; + + auto operator()(Args &&...args) const -> Return; + + explicit operator bool() const noexcept; + + [[nodiscard]] auto target_type() const noexcept -> const std::type_info &; + + template <typename Target> + auto target() const noexcept -> const Target *; + +private: + typename std::aligned_storage<3 * sizeof(void *)>::type _buf{}; + + TargetFunctor *_functor; + + static auto _as_copyable_functor(void *function_ptr) -> TargetFunctor *; +}; + +} // namespace yacppdic::internal + +#include "value_functor-impl.hpp" diff --git a/include/yacppdic/detail/internal/interfaces/copyable_functor.hpp b/include/yacppdic/detail/internal/interfaces/copyable_functor.hpp new file mode 100644 index 0000000..dadb214 --- /dev/null +++ b/include/yacppdic/detail/internal/interfaces/copyable_functor.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include <typeinfo> + +namespace yacppdic::internal +{ + +/** + * A copyable function object. + */ +template <class Function> +class ICopyableFunctor; + +template <class Return, class... Args> +class ICopyableFunctor<Return(Args...)> +{ +public: + ICopyableFunctor() = default; + + ICopyableFunctor(const ICopyableFunctor &) = delete; + + ICopyableFunctor(ICopyableFunctor &&) = delete; + + virtual ~ICopyableFunctor() = default; + + [[nodiscard]] virtual auto clone() const -> ICopyableFunctor * = 0; + + virtual void clone(ICopyableFunctor *) const = 0; + + virtual void destroy() noexcept = 0; + + virtual void destroy_deallocate() noexcept = 0; + + virtual auto operator()(Args &&...) -> Return = 0; + + auto operator=(const ICopyableFunctor &) = delete; + + auto operator=(ICopyableFunctor &&) = delete; + + [[nodiscard]] virtual auto target(const std::type_info &) const noexcept -> const + void * = 0; + + [[nodiscard]] virtual auto target_type() const noexcept -> const std::type_info & = 0; +}; + +} diff --git a/include/yacppdic/detail/internal/misc_concepts.hpp b/include/yacppdic/detail/internal/misc_concepts.hpp new file mode 100644 index 0000000..5d9ecb2 --- /dev/null +++ b/include/yacppdic/detail/internal/misc_concepts.hpp @@ -0,0 +1,11 @@ +#pragma once + +#include <type_traits> + +namespace yacppdic::internal +{ + +template <typename FirstType, typename SecondType> +concept NotSameAs = !std::is_same_v<FirstType, SecondType>; + +} diff --git a/include/yacppdic/detail/internal/strip_signature.hpp b/include/yacppdic/detail/internal/strip_signature.hpp new file mode 100644 index 0000000..30a2ad0 --- /dev/null +++ b/include/yacppdic/detail/internal/strip_signature.hpp @@ -0,0 +1,108 @@ +#pragma once + +namespace yacppdic::internal +{ + +template <class Function> +struct StripSignature; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...)> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) const> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) volatile> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) const volatile> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) &> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) const &> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) volatile &> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) const volatile &> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) noexcept> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) const noexcept> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) volatile noexcept> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) const volatile noexcept> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) &noexcept> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) const &noexcept> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) volatile &noexcept> +{ + using type = Return(Args...); +}; + +template <class Return, class Class, class... Args> +struct StripSignature<Return (Class::*)(Args...) const volatile &noexcept> +{ + using type = Return(Args...); +}; + +template <class Function> +using StripSignatureT = typename StripSignature<Function>::type; + +} // namespace yacppdic::internal diff --git a/include/yacppdic/detail/internal/type_utils.hpp b/include/yacppdic/detail/internal/type_utils.hpp new file mode 100644 index 0000000..f008352 --- /dev/null +++ b/include/yacppdic/detail/internal/type_utils.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include <type_traits> + +namespace yacppdic::internal +{ + +template <class Type> +struct UnConstVolatileReference +{ + using type = + typename std::remove_cv<typename std::remove_reference<Type>::type>::type; +}; + +template <class Type> +using UnConstVolatileReferenceT = typename UnConstVolatileReference<Type>::type; + +template <class Tp, class Up, class = void> +struct IsCoreConvertible : public std::false_type +{ +}; + +template <class Tp, class Up> +struct IsCoreConvertible< + Tp, + Up, + decltype(static_cast<void (*)(Up)>(0)(static_cast<Tp (*)()>(0)()))> + : public std::true_type +{ +}; + +template <class Tp, class Up> +constexpr bool IsCoreConvertibleV = IsCoreConvertible<Tp, Up>::value; + +} // namespace yacppdic::internal diff --git a/include/yacppdic/detail/internal/wrapper/function_wrapper-impl.hpp b/include/yacppdic/detail/internal/wrapper/function_wrapper-impl.hpp new file mode 100644 index 0000000..fc9492a --- /dev/null +++ b/include/yacppdic/detail/internal/wrapper/function_wrapper-impl.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include "function_wrapper.hpp" + +#include <utility> + +namespace yacppdic::internal +{ + +template <class Interface> +FunctionWrapper<Interface>::FunctionWrapper(Interface func) noexcept + : _func(std::move(func)) +{ +} + +template <class Interface> +auto FunctionWrapper<Interface>::get() const noexcept -> Interface +{ + return _func; +} + +} diff --git a/include/yacppdic/detail/internal/wrapper/function_wrapper.hpp b/include/yacppdic/detail/internal/wrapper/function_wrapper.hpp new file mode 100644 index 0000000..bec873b --- /dev/null +++ b/include/yacppdic/detail/internal/wrapper/function_wrapper.hpp @@ -0,0 +1,26 @@ +#pragma once + +#include "yacppdic/interfaces/wrapper.hpp" + +#include "yacppdic/container.hpp" + +#include <memory> + +namespace yacppdic::internal +{ + +template <class Interface> +class FunctionWrapper : public IWrapper<Interface> +{ +public: + explicit FunctionWrapper(Interface func) noexcept; + + [[nodiscard]] auto get() const noexcept -> Interface override; + +private: + const Interface _func; +}; + +} // namespace yacppdic::internal + +#include "function_wrapper-impl.hpp" diff --git a/include/yacppdic/detail/internal/wrapper/object_wrapper-impl.hpp b/include/yacppdic/detail/internal/wrapper/object_wrapper-impl.hpp new file mode 100644 index 0000000..01a3dff --- /dev/null +++ b/include/yacppdic/detail/internal/wrapper/object_wrapper-impl.hpp @@ -0,0 +1,15 @@ +#pragma once + +#include "object_wrapper.hpp" + +namespace yacppdic::internal +{ + +template <class Interface, class ObjectImpl> +auto ObjectWrapper<Interface, ObjectImpl>::get() const noexcept + -> std::unique_ptr<Interface> +{ + return ObjectImpl::resolve(_container); +} + +} // namespace yacppdic::internal diff --git a/include/yacppdic/detail/internal/wrapper/object_wrapper.hpp b/include/yacppdic/detail/internal/wrapper/object_wrapper.hpp new file mode 100644 index 0000000..f3c5e87 --- /dev/null +++ b/include/yacppdic/detail/internal/wrapper/object_wrapper.hpp @@ -0,0 +1,26 @@ +#pragma once + +#include "yacppdic/interfaces/wrapper.hpp" + +#include "yacppdic/container.hpp" + +#include <memory> + +namespace yacppdic::internal +{ + +template <class Interface, class ObjectImpl> +class ObjectWrapper : public IWrapper<std::unique_ptr<Interface>> +{ +public: + explicit ObjectWrapper(const Container &container) noexcept : _container(container) {} + + [[nodiscard]] auto get() const noexcept -> std::unique_ptr<Interface> override; + +private: + const Container &_container; +}; + +} // namespace yacppdic::internal + +#include "object_wrapper-impl.hpp" diff --git a/include/yacppdic/detail/object_type-impl.hpp b/include/yacppdic/detail/object_type-impl.hpp new file mode 100644 index 0000000..f12f99e --- /dev/null +++ b/include/yacppdic/detail/object_type-impl.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include "yacppdic/object_type.hpp" + +BaseObjectType::BaseObjectType(const std::type_info &type_info) noexcept + : _type_info(type_info) +{ +} + +auto BaseObjectType::operator==(const BaseObjectType &object_type) const noexcept -> bool +{ + return hash() == object_type.hash(); +} + +auto BaseObjectType::hash() const noexcept -> std::size_t +{ + return _type_info.hash_code(); +} + +auto BaseObjectType::name() const noexcept -> std::string_view +{ + return { _type_info.name() }; +} + +auto ObjectTypeHasher::operator()(const BaseObjectType &object_type) const noexcept + -> std::size_t +{ + return object_type.hash(); +} diff --git a/include/yacppdic/factory.hpp b/include/yacppdic/factory.hpp new file mode 100644 index 0000000..368175a --- /dev/null +++ b/include/yacppdic/factory.hpp @@ -0,0 +1,171 @@ +#pragma once + +#include "yacppdic/detail/internal/interfaces/copyable_functor.hpp" + +#include "yacppdic/detail/internal/alloc_destructor.hpp" +#include "yacppdic/detail/internal/functor/alloc_functor.hpp" +#include "yacppdic/detail/internal/functor/copyable_functor.hpp" +#include "yacppdic/detail/internal/functor/value_functor.hpp" +#include "yacppdic/detail/internal/misc_concepts.hpp" +#include "yacppdic/detail/internal/strip_signature.hpp" +#include "yacppdic/detail/internal/type_utils.hpp" + +#include <type_traits> +#include <utility> + +namespace yacppdic +{ + +template <class> +class Factory; + +template <class Return> +// NOLINTNEXTLINE(readability-identifier-naming) +struct maybe_derive_from_unary_function +{ +}; + +template <class Return, class Arg> +struct maybe_derive_from_unary_function<Return(Arg)> + : public std::unary_function<Arg, Return> +{ +}; + +template <class Return> +// NOLINTNEXTLINE(readability-identifier-naming) +struct maybe_derive_from_binary_function +{ +}; + +template <class Return, class ArgOne, class ArgTwo> +struct maybe_derive_from_binary_function<Return(ArgOne, ArgTwo)> + : public std::binary_function<ArgOne, ArgTwo, Return> +{ +}; + +template <class Function> +auto not_null(Function const & /*unused*/) -> bool +{ + return true; +} + +template <class Function> +auto not_null(Function *function_ptr) -> bool +{ + return function_ptr; +} + +template <class Return, class Class> +auto not_null(Return Class::*method_ptr) -> bool +{ + return method_ptr; +} + +template <class Function> +auto not_null(Factory<Function> const &factory) -> bool +{ + return !!factory; +} + +template <typename Function, typename Return, typename... Args> +concept Callable = + !std::is_same_v< + internal::UnConstVolatileReferenceT<Function>, + Factory<Return(Args...)>> && + std::is_invocable_v<Function, Args...> && + internal::IsCoreConvertibleV<std::invoke_result_t<Function, Args...>, Return>; + +template <class Return, class... Args> +class Factory<Return(Args...)> : public maybe_derive_from_unary_function<Return(Args...)>, + public maybe_derive_from_binary_function<Return(Args...)> +{ +public: + using Result = Return; + + Factory() noexcept = default; + + explicit Factory(std::nullptr_t) noexcept {} + + Factory(const Factory &factory); + + Factory(Factory &&factory) noexcept; + + template <class Function> + requires Callable<Function, Return, Args...> + // NOLINTNEXTLINE(google-explicit-constructor) + Factory(Function function) : _functor(std::move(function)) + { + } + + auto operator=(const Factory &factory) = delete; + + auto operator=(Factory &&factory) noexcept -> Factory &; + + auto operator=(std::nullptr_t) noexcept -> Factory &; + + ~Factory(); + + explicit operator bool() const noexcept; + + // deleted overloads close possible hole in the type system + template <class RhsReturn, class... RhsArgs> + auto operator==(const Factory<RhsReturn(RhsArgs...)> &) const -> bool = delete; + + template <class RhsReturn, class... RhsArgs> + auto operator!=(const Factory<RhsReturn(RhsArgs...)> &) const -> bool = delete; + + auto operator()(Args... args) const -> Return; + + [[nodiscard]] auto target_type() const noexcept -> const std::type_info &; + + template <typename Tp> + auto target() noexcept -> Tp *; + + template <typename Tp> + auto target() const noexcept -> const Tp *; + +private: + using ValFunctor = internal::ValueFunctor<Return(Args...)>; + + ValFunctor _functor; +}; + +template <class Return, class... Args> +Factory(Return (*)(Args...)) -> Factory<Return(Args...)>; + +template < + class Function, + class Stripped = internal::StripSignatureT<decltype(&Function::operator())>> +Factory(Function) -> Factory<Stripped>; + +template <class Return, class... Args> +inline auto operator==(const Factory<Return(Args...)> &factory, std::nullptr_t) noexcept + -> bool +{ + return !factory; +} + +template <class Return, class... Args> +inline auto operator==(std::nullptr_t, const Factory<Return(Args...)> &factory) noexcept + -> bool +{ + return !factory; +} + +template <class Return, class... Args> +inline auto operator!=(const Factory<Return(Args...)> &factory, std::nullptr_t) noexcept + -> bool +{ + return static_cast<bool>(factory); +} + +template <class Return, class... Args> +inline auto operator!=(std::nullptr_t, const Factory<Return(Args...)> &factory) noexcept + -> bool +{ + return static_cast<bool>(factory); +} + +} // namespace yacppdic + +#include "yacppdic/detail/factory-impl.hpp" diff --git a/include/yacppdic/interfaces/wrapper.hpp b/include/yacppdic/interfaces/wrapper.hpp new file mode 100644 index 0000000..e22ea7f --- /dev/null +++ b/include/yacppdic/interfaces/wrapper.hpp @@ -0,0 +1,17 @@ +#pragma once + +#include <memory> + +// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions) +class IGenericWrapper +{ +public: + virtual ~IGenericWrapper() noexcept = default; +}; + +template <class Interface> +class IWrapper : public IGenericWrapper +{ +public: + [[nodiscard]] virtual auto get() const noexcept -> Interface = 0; +}; diff --git a/include/yacppdic/object_type.hpp b/include/yacppdic/object_type.hpp new file mode 100644 index 0000000..eb4ce0c --- /dev/null +++ b/include/yacppdic/object_type.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include <string_view> +#include <typeinfo> + +class BaseObjectType +{ +public: + explicit BaseObjectType(const std::type_info &type_info) noexcept; + + auto operator==(const BaseObjectType &object_type) const noexcept -> bool; + + [[nodiscard]] auto hash() const noexcept -> std::size_t; + + [[nodiscard]] auto name() const noexcept -> std::string_view; + +private: + const std::type_info &_type_info; +}; + +template <class Object> +class ObjectType : public BaseObjectType +{ +public: + ObjectType() noexcept : BaseObjectType(typeid(Object)) {} +}; + +class ObjectTypeHasher +{ +public: + auto operator()(const BaseObjectType &object_type) const noexcept -> std::size_t; +}; + +#include "yacppdic/detail/object_type-impl.hpp" diff --git a/include/yacppdic/type_traits.hpp b/include/yacppdic/type_traits.hpp new file mode 100644 index 0000000..ab05caa --- /dev/null +++ b/include/yacppdic/type_traits.hpp @@ -0,0 +1,23 @@ +#pragma once + +#include "yacppdic/factory.hpp" + +#include <type_traits> + +namespace yacppdic +{ + +template <typename NotAFunction> +struct is_factory : public std::false_type // NOLINT(readability-identifier-naming) +{ +}; + +template <typename Return, typename... Args> +struct is_factory<Factory<Return(Args...)>> : public std::true_type +{ +}; + +template <typename PossiblyFunction> +inline constexpr bool is_factory_v = is_factory<PossiblyFunction>::value; + +} |