AnyNode.h

#ifndef ANY_NODE_H
#define ANY_NODE_H

#ifdef _MSC_VER
# include <iso646.h>
#endif 

#include <typeinfo>
#include <cassert>
#include <type_traits>
#include <ostream>
#include <memory>
#include "ValueHolder.h"

namespace te {

/* Forward declarations. */

template <class H, class E, class A>
struct AnySet;

template <class H, class E, class A>
std::ostream& operator<<(std::ostream& os, const AnySet<H, E, A>& set);


namespace detail {

/* Some type traits. */

template <class S, class T>
class is_streamable_helper
{
    template<class Stream, class Type>
    static auto test(int) -> decltype( 
        (std::declval<Stream>() << std::declval<Type>()), std::true_type() 
    );

    template<class, class>
    static auto test(...) -> std::false_type;

public:
    static constexpr const bool value = decltype(test<S,T>(0))::value;
};

template <class T>
using is_streamable = is_streamable_helper<std::ostream&, T>;

template <class T>
inline constexpr const bool is_streamable_v = is_streamable<T>::value;

template <class T, class = void>
struct is_equality_comparable: std::false_type {};
template <class T>
struct is_equality_comparable<
    T, 
    std::enable_if_t<
        true, 
        decltype((void)(std::declval<T>() == std::declval<T>()))
        >
    >: std::true_type {};
template <class T>
inline constexpr const bool is_equality_comparable_v = is_equality_comparable<T>::value;

template <class T, class = void>
struct is_inequality_comparable: std::false_type {};
template <class T>
struct is_inequality_comparable<
    T, 
    std::enable_if_t<
        true, 
        decltype((void)(std::declval<T>() != std::declval<T>()), (void)0)
        >
    >: std::true_type {};
template <class T>
inline constexpr const bool is_inequality_comparable_v = is_inequality_comparable<T>::value;

template <class Value, class HashFn, class Compare>
struct TypedValue;

template <class Value, class HashFn, class Compare>
struct AnyValueLink;

template <class HashFn, class Compare>
struct AnyList;

} /* namespace detail */

/* More forward declarations. */

template <class HashFn, class Compare>
struct AnyValue;

template <class T, class H, class C>
bool is(const AnyValue<H, C>& any_v);


template <class T, class H, class C>
const T* try_as(const AnyValue<H, C>& self);

template <class T, class H, class C>
const T& as(const AnyValue<H, C>& self);


struct CopyConstructionError:
    std::logic_error
{
    CopyConstructionError(const std::type_info& ti):
        std::logic_error("Attempt to copy construct type that is not copy constructible."), 
        typeinfo(ti)
    {
        
    }

    virtual const char* what() const noexcept override 
    {
        // make what() visible to doxygen
        return this->std::logic_error::what();
    }

    const std::type_info& typeinfo;
};

template <class T>
struct NoCopyConstructorError final:
    public CopyConstructionError
{
    static_assert(not std::is_copy_constructible_v<T>);

    NoCopyConstructorError():
        CopyConstructionError(typeid(T))
    {
        
    }
};

namespace detail {

template <class T, class H, class C, class ... Args>
std::unique_ptr<TypedValue<T, H, C>> make_typed_value(std::size_t hash_v, Args&& ... args);

template <class T, class H, class C, class ... Args>
std::unique_ptr<TypedValue<T, H, C>> make_typed_value(H hash_fn, Args&& ... args);

} /* namespace detail */


template <class T, class H, class C, class ... Args>
std::unique_ptr<AnyValue<H, C>> make_any_value(std::size_t hash_value, Args&& ... args);

template <class T, class H, class C, class ... Args>
std::unique_ptr<AnyValue<H, C>> make_any_value(H hasher, Args&& ... args);


template <class HashFn, class Compare>
struct AnyValue
{
    using self_type = AnyValue<HashFn, Compare>;
    using hasher = HashFn;
    using key_equal = Compare;
    virtual ~AnyValue() = default;

    AnyValue(const AnyValue&) = delete;
    AnyValue(AnyValue&&) = delete;


    template <class T>
    friend bool operator==(const AnyValue& left, const T& right)
    {
        if(const T* p = try_as<T>(left); static_cast<bool>(p))
            return *p == right; 
        return false;
    }
    
    template <class T>
    friend bool operator==(const T& left, const AnyValue& right)
    {
        if(const T* p = try_as<T>(right); static_cast<bool>(p))
            return left == *p; 
        return false;
    }

    template <class T>
    friend bool operator!=(const T& left, const AnyValue& right)
    {
        if(const T* p = try_as<T>(right); static_cast<bool>(p))
            return left != *p; 
        return true;
    }

    template <class T>
    friend bool operator!=(const AnyValue& left, const T& right)
    {
        if(const T* p = try_as<T>(left); static_cast<bool>(p))
            return *p != right; 
        return true;
    }

    friend bool operator==(const AnyValue& left, const AnyValue& right)
    { return left.equals(right); }

    friend bool operator!=(const AnyValue& left, const AnyValue& right)
    { return left.not_equals(right); }

    friend bool compare(const AnyValue& left, const AnyValue& right, Compare comp)
    { return left.compare_to(right, comp); }

    template <class T, class Comp = Compare, class = std::enable_if_t<not std::is_same_v<T, self_type>>>
    friend bool compare(const T& left, const AnyValue& right, Comp comp)
    {
        if(const T* p = try_as<T>(right); static_cast<bool>(p))
            return comp(left, *p);
        return false;
    }

    template <class T, class Comp = Compare, class = std::enable_if_t<not std::is_same_v<T, self_type>>>
    friend bool compare(const AnyValue& left, const T& right, Comp comp)
    {
        if(const T* p = try_as<T>(left); static_cast<bool>(p))
            return comp(*p, right);
        return false;
    }



    friend std::ostream& operator<<(std::ostream& os, const AnyValue& any_v)
    {
        any_v.write(os);
        return os;
    }

    virtual const std::type_info& typeinfo() const = 0;

protected:
    AnyValue(std::size_t hash_v):
        hash(hash_v)
    {
        
    }

    virtual bool compare_to(const AnyValue& other, Compare comp) const = 0;
    virtual bool equals(const AnyValue& other) const = 0;
    virtual bool not_equals(const AnyValue& other) const = 0;
    virtual void write(std::ostream& os) const = 0;
    virtual std::unique_ptr<self_type> clone() const = 0;

public:
    const std::size_t hash;
private:
    self_type* next{nullptr};
    template <class, class, class>  
    friend struct AnySet;
    friend struct detail::AnyList<HashFn, Compare>;

};

namespace detail {

template <class Value, class HashFn, class Compare>
struct AnyValueLink;

template <class Value, class HashFn, class Compare>
struct TypedValue:
    public AnyValue<HashFn, Compare>
{
    using base_type = AnyValue<HashFn, Compare>;
    using value_type = Value;
    using holder_type = ConstValueHolder<value_type>;
    using self_type = TypedValue<Value, HashFn, Compare>;
    using link_type = AnyValueLink<Value, HashFn, Compare>;

    virtual ~TypedValue() = default;

    TypedValue(const self_type&) = delete;
    TypedValue(self_type&&) = delete;

    self_type& operator=(const self_type&) = delete;
    self_type& operator=(self_type&&) = delete;

protected:
    TypedValue(std::size_t hash_v):
        base_type(hash_v)
    {
        
    }
public:
    
    bool equals(const base_type& other) const final override
    {
        if constexpr(detail::is_equality_comparable_v<Value>)
            if(const Value* v = try_as<Value>(other); static_cast<bool>(v))
                return (*v) == this->value();
            else
                return false;
        else
            return false;
    }
    
    bool not_equals(const base_type& other) const final override
    {
        if constexpr(detail::is_inequality_comparable_v<Value>)
            if(const Value* v = try_as<Value>(other); static_cast<bool>(v))
                return (*v) != this->value();
            else
                return false;
        else
            return true;
    }

    bool compare_to(const base_type& other, Compare comp) const final override
    {
        auto* p = try_as<Value>(other);
        return static_cast<bool>(p) and comp(*p, this->value()); 
    }

    void write(std::ostream& os) const final override
    {
        if constexpr(detail::is_streamable_v<Value>)
            os << this->value();
        else
            os << "AnyValue(typeid.name='" << typeinfo().name() << "', hash=" << this->hash << ')';
    }

    std::unique_ptr<base_type> clone() const final override
    {
        if constexpr(std::is_copy_constructible_v<Value>)
            return make_any_value<Value, HashFn, Compare>(this->hash, this->value());
        else
            throw NoCopyConstructorError<Value>();
    }

    const std::type_info& typeinfo() const final override
    { return typeid(Value); }

    const value_type& value() const&
    { return get_value(as_link()); } 

    const value_type&& value() const&&
    { return std::move(get_value(as_link())); } 

private:
    const link_type& as_link() const& noexcept
    { return static_cast<const link_type&>(*this); }

    const link_type&& as_link() const&& noexcept
    { return static_cast<const link_type&&>(*this); }

    friend const Value* try_as<Value>(const AnyValue<HashFn, Compare>& self);
};

template <class Value, class HashFn, class Compare>
struct AnyValueLink final:
    public ConstValueHolder<Value>,
    public TypedValue<Value, HashFn, Compare>
{
    friend struct TypedValue<Value, HashFn, Compare>;
    using self_type = AnyValueLink<Value, HashFn, Compare>;
    using holder_type = ConstValueHolder<Value>;
    using base_type = TypedValue<Value, HashFn, Compare>;
public:
    virtual ~AnyValueLink() final = default;

    template <class ... Args>
    AnyValueLink(std::size_t hash_v, Args&& ... args):
        holder_type(std::forward<Args>(args)...),
        base_type(hash_v)
    {
        
    }

    template <class ... Args>
    AnyValueLink(HashFn hasher, Args&& ... args):
        holder_type(std::forward<Args>(args)...),
        base_type(hasher(get_value(*this)))
    {
        
    }

    friend const Value& get_value(const self_type& self)
    { return get_value(static_cast<const holder_type&>(self)); }

    friend const Value&& get_value(const self_type&& self)
    { return get_value(static_cast<const holder_type&&>(self)); }

};

} /* namespace detail */


template <class T, class H, class C, class ... Args>
std::unique_ptr<detail::TypedValue<T, H, C>> detail::make_typed_value(std::size_t hash_v, Args&& ... args)
{
    auto tmp = std::make_unique<AnyValueLink<T, H, C>>(hash_v, std::forward<Args>(args) ...);
    return std::unique_ptr<TypedValue<T, H, C>>(
        static_cast<TypedValue<T, H, C>*>(tmp.release())
    );
}

template <class T, class H, class C, class ... Args>
std::unique_ptr<detail::TypedValue<T, H, C>> detail::make_typed_value(H hash_fn, Args&& ... args)
{
    auto tmp = std::make_unique<AnyValueLink<T, H, C>>(hash_fn, std::forward<Args>(args) ...);
    return std::unique_ptr<TypedValue<T, H, C>>(
        static_cast<TypedValue<T, H, C>*>(tmp.release())
    );
}

template <class T, class H, class C, class ... Args>
std::unique_ptr<AnyValue<H, C>> make_any_value(std::size_t hash_value, Args&& ... args)
{
    auto tmp = detail::make_typed_value<T, H, C>(hash_value, std::forward<Args>(args)...);
    return std::unique_ptr<AnyValue<H, C>>(
        static_cast<AnyValue<H, C>*>(tmp.release())
    );
}

template <class T, class H, class C, class ... Args>
std::unique_ptr<AnyValue<H, C>> make_any_value(H hasher, Args&& ... args)
{
    auto tmp = detail::make_typed_value<T, H, C>(hasher, std::forward<Args>(args)...);
    return std::unique_ptr<AnyValue<H, C>>(
        static_cast<AnyValue<H, C>*>(tmp.release())
    );
}



template <class To, class H, class C>
To polymorphic_cast(const AnyValue<H, C>& any_v)
{
    static_assert(
        std::is_same_v<const std::decay_t<To>&, To>, 
        "Can only polymorphic_cast an AnyValue reference to a const reference type."
    );
    static_assert(
        std::is_class_v<std::decay_t<To>> and not std::is_final_v<std::decay_t<To>>,
        "Cannot 'polymorphic_cast()' to final or non-class type."
    );
    return dynamic_cast<To>(any_v);
}

template <class To, class H, class C>
To polymorphic_cast(const AnyValue<H, C>* any_v)
{
    using type = std::decay_t<std::remove_pointer_t<std::decay_t<To>>>;
    static_assert(
        std::is_same_v<const type*, To>, 
        "Can only polymorphic_cast an AnyValue pointer to a pointer to const type."
    );
    static_assert(std::is_class_v<type> and not std::is_final_v<type>, 
        "Cannot 'polymorphic_cast()' to final or non-class type."
    );
    return dynamic_cast<To>(any_v);
}

template <class To, class H, class C>
To exact_cast(const AnyValue<H, C>& any_v)
{
    using to_type = std::decay_t<To>;
    if(is<to_type>(any_v))
        return static_cast<const detail::TypedValue<to_type, H, C>&>(any_v).value();
    else
        throw std::bad_cast();
}

template <class To, class H, class C>
To exact_cast(const AnyValue<H, C>* any_v)
{
    static_assert(
        std::is_pointer_v<To>, 
        "exact_cast<T>(const AnyValue<H, C>*) requires that T be a pointer type."
    );
    using to_type = std::decay_t<std::remove_pointer_t<To>>;
    if(is<to_type>(*any_v))
        return std::addressof(
            static_cast<const detail::TypedValue<to_type, H, C>&>(*any_v).value()
        );
    else
        return nullptr;
}

template <class To, class H, class C>
To unsafe_cast(const AnyValue<H, C>& any_v) 
{
    return static_cast<const detail::TypedValue<std::decay_t<To>, H, C>&>(any_v).value();
}



template <class T, class H, class C>
const T* try_as(const AnyValue<H, C>& any_v) 
{
    static_assert(std::is_object_v<T>);
    if(const T* p = exact_cast<const T*>(&any_v); static_cast<bool>(p))
        return p;
    else if constexpr(std::is_class_v<T> and not std::is_final_v<T>)
    {
        if(p = polymorphic_cast<const T*>(&any_v); static_cast<bool>(p))
            return p;
    }
    return nullptr;
}

template <class T, class H, class C>
const T& as(const AnyValue<H, C>& self)
{
    if(const auto* p = try_as<T>(self); static_cast<bool>(p))
        return *p;
    throw std::bad_cast();
}

template <class T, class H, class C>
bool is(const AnyValue<H, C>& any_v)
{ return any_v.typeinfo() == typeid(T); }


template <class T, class H, class C>
const T& get(const AnyValue<H, C>& any_v)
{
    return as<T>(any_v);
}

template <class T, class H, class C, class DefaultRef>
const std::decay_t<T>& get_default_ref(const AnyValue<H, C>& any_v, DefaultRef&& default_ref)
{
    static_assert(
        std::is_same_v<T, std::decay_t<T>>, 
        "T should be a naked type (no cv qualifiers, or refereces) in get_default_ref<T>()"
    );

    static_assert(
        std::is_same_v<std::decay_t<T>, std::decay_t<DefaultRef>>, 
        "The second argument (the 'default') in get_default_ref<T>() must have the same type as T."
    );

    static_assert(
        not std::is_rvalue_reference_v<decltype(default_ref)>,
        "get_default_ref() cannot be called with an rvalue (would return a dangling reference)."
    );
    
    if(const std::decay_t<T>* p = try_as<T>(any_v); static_cast<bool>(p))
        return *p;
    else
        return std::forward<DefaultRef>(default_ref);
}

template <class T, class H, class C, class DefaultVal>
T get_default_val(const AnyValue<H, C>& any_v, DefaultVal&& default_val)
{
    static_assert(
        std::is_same_v<T, std::decay_t<T>>, 
        "T should be a naked type (no cv qualifiers, or refereces) in get_default_val<T>()"
    );

    static_assert(
        std::is_constructible_v<std::decay_t<T>, DefaultVal>,
        "Cannot construct return value of get_default_val() with given argument for the default value (the second arguments)."
    );

    static_assert(
        std::is_constructible_v<std::decay_t<T>, const std::decay_t<T>>,
        "Cannot construct return value of get_default_val() with the value contained in AnyValue (const reference)."
    );

    if(const T* p = try_as<T>(any_v); static_cast<bool>(p))
        return *p;
    else
        return static_cast<T>(std::forward<DefaultVal>(default_val));
}



} /* namespace te */    

#endif /* ANY_NODE_H */