smart_adapter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <memory>
#include <type_traits>
 
#include "adapter.h"
 
namespace kcenon::common::adapters {
 
template<typename T, typename Interface>
inline constexpr bool implements_interface_v = std::is_base_of_v<Interface, T> ||
                                                std::is_convertible_v<T*, Interface*>;
 
class smart_adapter_factory {
public:
    template<typename Interface, typename Impl>
    static std::shared_ptr<Interface> make_adapter(std::shared_ptr<Impl> impl) {
        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);
        }
    }
 
    template<typename AdapterType, typename... Args>
    static std::shared_ptr<AdapterType> make_explicit_adapter(Args&&... args) {
        return std::make_shared<AdapterType>(std::forward<Args>(args)...);
    }
 
    template<typename T, typename Interface>
    static std::shared_ptr<T> try_unwrap(std::shared_ptr<Interface> ptr) {
        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;
    }
 
    template<typename Interface, typename Impl>
    static constexpr bool is_zero_cost() {
        return implements_interface_v<Impl, Interface>;
    }
};
 
template<typename Interface, typename Impl>
std::shared_ptr<Interface> make_smart_adapter(std::shared_ptr<Impl> impl) {
    return smart_adapter_factory::make_adapter<Interface, Impl>(impl);
}
 
template<typename T, typename Interface>
std::shared_ptr<T> unwrap_adapter(std::shared_ptr<Interface> ptr) {
    return smart_adapter_factory::try_unwrap<T, Interface>(ptr);
}
 
} // namespace common::adapters