cetl::pmr::InterfaceFactory Class Reference

#include "cetl/pmr/interface_ptr.hpp"

Static Public Member Functions
template<typename Interface, typename PmrAllocator, typename... Args>
static CETL_NODISCARD InterfacePtr< Interface >	make_unique (PmrAllocator alloc, Args &&... args)

Detailed Description

Interface Factory helper for creating objects with polymorphic allocators using proper RAII semantics.

Uses the cetl::pmr::PmrInterfaceDeleter type to ensure proper type-erased deallocation.

Example usage:

 
cetl::pmr::polymorphic_allocator<MyObject> alloc{cetl::pmr::get_default_resource()};
 
auto obj0 = cetl::pmr::InterfaceFactory::make_unique<MyObject>(alloc, "obj0", 4U);
std::cout << "Obj0 id  : " << obj0->id() << std::endl;
 
// Commented b/c of current limitation of our `cetl::pmr::function`.
// Probably PMR support is needed at `cetl::unbounded_variant` (which we use inside the `function`),
// so that it will be possible to nest one deleter inside another one.
auto obj1 = cetl::pmr::InterfaceFactory::make_unique<IIdentifiable>(alloc, "obj1", 4U);
{
    std::cout << "Obj1 id  : " << obj1->id() << std::endl;
    obj1.reset();
    std::cout << std::endl;
}
 
auto obj2 = cetl::pmr::InterfaceFactory::make_unique<IDescribable>(alloc, "obj2", 4U);
{
    std::cout << "Obj2 desc  : " << obj2->describe() << std::endl;
    std::cout << "Obj2 name_a  : " << obj2->name() << std::endl;
 
    // Such interface ptr upcasting currently is not supported.
    //
    //    auto obj2_named = InterfacePtr<INamed>{std::move(obj2)};
    //    std::cout << "Obj2 name_b  : " << obj2_named->name() << std::endl;
}
 
auto obj3 = cetl::pmr::InterfaceFactory::make_unique<INamed>(alloc, "obj3", 4U);
{
    std::cout << "Obj3 name  : " << obj3->name() << std::endl;
    std::cout << std::endl;
}
 

As shown in the next example, objects can maintain tight control of their lifecycle by befriending the allocators used to create cetl::pmr::InterfacePtr objects.

 
// Note that this concrete type is final because it extends `cetl::rtti` non-virtually which is not reccommended
// for any non-final type. Inversely, the InterfaceFactory only works with non-virtual inheritance of the interface
// used in the InterfacePtr type since a static downcast must be performed by the deleter.
// Finally, this encapsulation technique of befriending the polymorphic allocator will always work with CETL PMR
// but may not work with other standard libraries.
class MyConcreteType final : public cetl::rtti
{
public:
    using ConcreteAllocator = cetl::pf17::pmr::polymorphic_allocator<MyConcreteType>;
    // By making this allocator a friend we ensure that this class can only be created using PMR.
    friend ConcreteAllocator;
 
    // Since this class's constructor is private the only way to instantiate it is using a ConcreteAllocator. This
    // method bundles that constraint up with the proper RAII semantics making it easy to properly construct
    // MyConcreteType classes and hard to construct them improperly.
    template <typename... Args>
    static cetl::pmr::InterfacePtr<cetl::rtti> make(std::allocator_arg_t, ConcreteAllocator alloc, Args&&... args)
    {
        return cetl::pmr::InterfaceFactory::make_unique<cetl::rtti>(alloc, std::forward<Args>(args)...);
    }
 
    CETL_NODISCARD void* _cast_(const cetl::type_id&) & noexcept override
    {
        return nullptr;
    }
    CETL_NODISCARD const void* _cast_(const cetl::type_id&) const& noexcept override
    {
        return nullptr;
    }
 
private:
    MyConcreteType()          = default;
    virtual ~MyConcreteType() = default;
};
 

(See full example here...)

---

The documentation for this class was generated from the following file:

• /__w/CETL/CETL/include/cetl/pmr/interface_ptr.hpp