kcenon::common::adapters::adapter_factory Class Reference

Smart adapter factory that avoids unnecessary wrapping. More...

#include <adapter.h>

Collaboration diagram for kcenon::common::adapters::adapter_factory:

Static Public Member Functions
template<typename Interface , typename Impl >
static std::shared_ptr< Interface >	create (std::shared_ptr< Impl > impl)
	Create an adapter with automatic optimization.
template<typename AdapterType , typename... Args>
static std::shared_ptr< AdapterType >	create_explicit (Args &&... args)
	Create an adapter with explicit adapter type.
template<typename T , typename Interface >
static std::shared_ptr< T >	try_unwrap (std::shared_ptr< Interface > ptr)
	Try to unwrap an interface to get underlying implementation.
template<typename Interface , typename Impl >
static constexpr bool	is_zero_cost ()
	Check if zero-cost adaptation is possible.

Detailed Description

Smart adapter factory that avoids unnecessary wrapping.

This factory uses compile-time checks to determine if adaptation is needed:

• If the implementation already implements the interface, direct cast (zero-cost)
• Otherwise, create an interface_adapter wrapper

Definition at line 440 of file adapter.h.

Member Function Documentation

create()

template<typename Interface , typename Impl >

static std::shared_ptr< Interface > kcenon::common::adapters::adapter_factory::create ( std::shared_ptr< Impl > impl )

inlinestatic

Create an adapter with automatic optimization.

If Impl already implements Interface, returns a static_pointer_cast (zero-cost). Otherwise, creates an interface_adapter wrapper.

Template Parameters

Interface	The target interface type
Impl	The implementation type

Parameters

impl	Shared pointer to the implementation

Returns

Shared pointer to Interface (either direct cast or adapter)

Definition at line 455 of file adapter.h.

                                     {
        if constexpr (implements_interface_v<Impl, Interface>) {
            return std::static_pointer_cast<Interface>(impl);
        } else {
            return std::make_shared<interface_adapter<Interface, Impl>>(impl);
        }
    }

References kcenon::common::adapters::implements_interface_v.

Referenced by kcenon::common::adapters::make_interface_adapter().

Here is the caller graph for this function:

create_explicit()

template<typename AdapterType , typename... Args>

static std::shared_ptr< AdapterType > kcenon::common::adapters::adapter_factory::create_explicit ( Args &&... args )

inlinestatic

Create an adapter with explicit adapter type.

Template Parameters

AdapterType	The specific adapter class to use
Args	Constructor argument types

Parameters

args	Arguments to forward to adapter constructor

Returns

Shared pointer to the created adapter

Definition at line 472 of file adapter.h.

                                                                      {
        return std::make_shared<AdapterType>(std::forward<Args>(args)...);
    }

is_zero_cost()

template<typename Interface , typename Impl >

static constexpr bool kcenon::common::adapters::adapter_factory::is_zero_cost ( )

inlinestaticconstexpr

Check if zero-cost adaptation is possible.

Template Parameters

Interface	The target interface
Impl	The implementation type

Returns

true if direct cast is possible (zero-cost)

Definition at line 517 of file adapter.h.

                                         {
        return implements_interface_v<Impl, Interface>;
    }

References kcenon::common::adapters::implements_interface_v.

try_unwrap()

template<typename T , typename Interface >

static std::shared_ptr< T > kcenon::common::adapters::adapter_factory::try_unwrap ( std::shared_ptr< Interface > ptr )

inlinestatic

Try to unwrap an interface to get underlying implementation.

Template Parameters

T	The expected underlying type
Interface	The interface type

Parameters

ptr	Shared pointer to the interface

Returns

Shared pointer to T, or nullptr if conversion fails

Definition at line 485 of file adapter.h.

                                                                     {
        if (!ptr) {
            return nullptr;
        }
 
        if constexpr (std::is_base_of_v<adapter_base, Interface>) {
#ifdef __cpp_rtti
            if (auto* adapter =
                    dynamic_cast<interface_adapter<Interface, T>*>(ptr.get())) {
                return adapter->unwrap();
            }
#else
            auto* base = static_cast<adapter_base*>(ptr.get());
            if (base && base->get_type_id() ==
                            interface_adapter<Interface, T>::get_static_type_id()) {
                auto* adapter =
                    static_cast<interface_adapter<Interface, T>*>(ptr.get());
                return adapter->unwrap();
            }
#endif
        }
 
        return nullptr;
    }

Referenced by kcenon::common::adapters::safe_unwrap(), and kcenon::common::adapters::unwrap_adapter().

Here is the caller graph for this function:

---

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

• include/kcenon/common/adapters/adapter.h