kcenon::common::adapters::smart_adapter_factory Class Reference

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

#include <smart_adapter.h>

Collaboration diagram for kcenon::common::adapters::smart_adapter_factory:

Static Public Member Functions
template<typename Interface , typename Impl >
static std::shared_ptr< Interface >	make_adapter (std::shared_ptr< Impl > impl)
	Create an adapter with automatic optimization.
template<typename AdapterType , typename... Args>
static std::shared_ptr< AdapterType >	make_explicit_adapter (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

This provides zero-cost abstraction when possible.

Note

Consider using adapter_factory from adapter.h for new code

Definition at line 46 of file smart_adapter.h.

Member Function Documentation

is_zero_cost()

template<typename Interface , typename Impl >

static constexpr bool kcenon::common::adapters::smart_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 120 of file smart_adapter.h.

                                         {
        return implements_interface_v<Impl, Interface>;
    }

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

make_adapter()

template<typename Interface , typename Impl >

static std::shared_ptr< Interface > kcenon::common::adapters::smart_adapter_factory::make_adapter ( 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 a typed_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 60 of file smart_adapter.h.

                                                                           {
        if constexpr (implements_interface_v<Impl, Interface>) {
            // Zero-cost: Direct cast, no wrapper needed
            return std::static_pointer_cast<Interface>(impl);
        } else {
            // Create adapter wrapper
            return std::make_shared<interface_adapter<Interface, Impl>>(impl);
        }
    }

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

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

Here is the caller graph for this function:

make_explicit_adapter()

template<typename AdapterType , typename... Args>

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

inlinestatic

Create an adapter with explicit adapter type.

Always creates the specified adapter type, even if zero-cost cast is possible. Use this when you need specific adapter behavior beyond simple interface conversion.

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 82 of file smart_adapter.h.

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

try_unwrap()

template<typename T , typename Interface >

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

inlinestatic

Try to unwrap an interface to get underlying implementation.

If the interface is a interface_adapter, unwraps it. Otherwise, returns nullptr (strict type safety without RTTI).

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 98 of file smart_adapter.h.

                                                                     {
        if (!ptr) {
            return nullptr;
        }
 
        // Try safe_unwrap (for interface_adapter)
        if (auto unwrapped = safe_unwrap<T>(ptr)) {
            return unwrapped;
        }
 
        // Not an adapter - return nullptr for strict type safety
        // (removed dynamic_pointer_cast to eliminate RTTI dependency)
        return nullptr;
    }

References kcenon::common::adapters::safe_unwrap().

Here is the call graph for this function:

---

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

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