enumerator_adapter.h

 
#pragma once
 
#include <system/smart_ptr.h>
#include <system/boxable_traits.h>
#include <system/object_ext.h>
#include <system/make_const_ref.h>
#include <iterator>
#include <utility>
#include <type_traits>
 
namespace System { namespace Details {
 
template<typename Enumerable>
using EnumeratorOf = std::remove_reference_t<decltype(*(std::declval<Enumerable>().GetEnumerator()))>;
 
template<typename Enumerable>
using ValueTypeOfEnumerable = decltype(std::declval<EnumeratorOf<Enumerable>>().get_Current());
 
template<typename Enumerator>
using ValueTypeOfEnumerator = decltype(std::declval<Enumerator>().get_Current());
 
template <typename T, typename = void>
struct IsIterable : std::false_type {};
template <typename T>
struct IsIterable<T, decltype(std::declval<T>().begin(), std::declval<T>().end(), void())>
    : std::true_type {};
 
template<typename T>
using IterableValueType = decltype(*(std::declval<T>().begin()));
 
template<typename T, typename = void>
struct ReturnTypeTrait {};
 
template<typename T>
struct ReturnTypeTrait<T, std::enable_if_t<IsSmartPtr<T>::value>>
{
    using Pointee = std::remove_reference_t<decltype(*(std::declval<T>()))>;
    using ReturnType = SmartPtr<Pointee>;
    static constexpr bool value = true;
};
 
template<typename T>
struct ReturnTypeTrait<T, std::enable_if_t<!IsSmartPtr<T>::value && IsBoxable<T>::value>>
{
    using Pointee = void;
    using ReturnType = T;
    static constexpr bool value = false;
};
 
template<typename T>
struct ReturnTypeTrait<T, std::enable_if_t<!IsSmartPtr<T>::value && !IsBoxable<T>::value>>
{
    using Pointee = T;
    using ReturnType = SmartPtr<Pointee>;
    static constexpr bool value = true;
};
 
template<typename D, typename S>
using WithoutCast = std::integral_constant<bool, std::is_same<typename ReturnTypeTrait<D>::ReturnType, typename ReturnTypeTrait<S>::ReturnType>::value>;
 
template<typename D, typename S>
using WithDynamicCast = std::integral_constant<bool, ReturnTypeTrait<D>::value && ReturnTypeTrait<S>::value && !std::is_same<typename ReturnTypeTrait<D>::Pointee, typename ReturnTypeTrait<S>::Pointee>::value>;
 
template<typename D, typename S>
using WithUnboxing = std::integral_constant<bool, !ReturnTypeTrait<D>::value && ReturnTypeTrait<S>::value && std::is_same<typename ReturnTypeTrait<S>::Pointee, System::Object>::value>;
 
template<typename D, typename S>
using WithBoxing = std::integral_constant<bool, ReturnTypeTrait<D>::value && !ReturnTypeTrait<S>::value && std::is_same<typename ReturnTypeTrait<D>::Pointee, System::Object>::value>;
 
template<typename T, typename Enumerator>
struct WrappingIterator
{
    using TargetType = T;
    using SourceType = ValueTypeOfEnumerator<Enumerator>;
 
    using iterator_category = std::forward_iterator_tag;
    using value_type = typename ReturnTypeTrait<TargetType>::ReturnType;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;
 
    WrappingIterator() : mIsEnd(true) {}
    WrappingIterator(SmartPtr<Enumerator> enumerator) 
        : mEnumerator(std::move(enumerator))
        , mIsEnd(!mEnumerator->MoveNext())
    {}
 
    WrappingIterator(const WrappingIterator& other) = default;
    WrappingIterator(WrappingIterator&& other) noexcept = default;
    WrappingIterator& operator=(const WrappingIterator& other) = default;
    WrappingIterator& operator=(WrappingIterator&& other) noexcept = default;
    ~WrappingIterator() = default;
 
    bool operator!=(const WrappingIterator& other) const
    {
        if (mIsEnd && other.mIsEnd) return false;
 
        if (mIsEnd || other.mIsEnd) return true;
 
        // The correct comparison, but we use this iterator only for range-based loops
        // so it doesn't matter
        // mEnumerator->get_Current() != other.mEnumerator->get_Current();
        return false;
    }
 
    template<typename Q = TargetType>
    std::enable_if_t<WithoutCast<Q, SourceType>::value, MakeConstRef_t<SourceType>>
    operator*() const
    {
        return mEnumerator->get_Current();
    }
 
    template<typename Q = TargetType>
    std::enable_if_t<WithDynamicCast<Q, SourceType>::value, value_type>
    operator*() const
    {
        return System::ExplicitCast<typename ReturnTypeTrait<Q>::Pointee>(mEnumerator->get_Current());
    }
 
    template<typename Q = TargetType>
    std::enable_if_t<WithUnboxing<Q, SourceType>::value, value_type>
    operator*() const
    {
        return ObjectExt::Unbox<typename ReturnTypeTrait<Q>::ReturnType>(mEnumerator->get_Current());
    }
 
    template<typename Q = TargetType>
    std::enable_if_t<WithBoxing<Q, SourceType>::value, value_type>
    operator*() const
    {
        return ObjectExt::Box(mEnumerator->get_Current());
    }
 
    WrappingIterator& operator++()
    {
        mIsEnd = ! mEnumerator->MoveNext();
        return *this;
    }
 
private:
    SmartPtr<Enumerator> mEnumerator;
    bool mIsEnd;
};
 
template<typename Enumerable, typename T = ValueTypeOfEnumerable<Enumerable>, typename Payload = SmartPtr<Enumerable>>
struct EnumeratorAdapter
{
    using iterator = WrappingIterator<T, EnumeratorOf<Enumerable>>;
 
    EnumeratorAdapter(Payload enumerable) : mEnumerable(std::move(enumerable)) {}
 
    iterator begin()
    {
        return WrappingIterator<T, EnumeratorOf<Enumerable>>(mEnumerable->GetEnumerator());
    }
 
    iterator end()
    {
        return iterator();
    }
 
private:
    Payload mEnumerable;
};
 
 
template<typename T, typename Iterator>
struct AdaptedIterator
{
    using TargetType = T;
    using SourceType = typename std::iterator_traits<Iterator>::value_type;
 
    using iterator_category = std::forward_iterator_tag;
    using value_type = typename ReturnTypeTrait<TargetType>::ReturnType;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;
 
    AdaptedIterator(Iterator origin_iterator)
        : mOriginIterator(std::move(origin_iterator))
    {
    }
 
    AdaptedIterator(const AdaptedIterator& other) = default;
    AdaptedIterator(AdaptedIterator&& other) noexcept = default;
    AdaptedIterator& operator=(const AdaptedIterator& other) = default;
    AdaptedIterator& operator=(AdaptedIterator&& other) noexcept = default;
 
 
    friend bool operator==(const AdaptedIterator& lhs, const AdaptedIterator& rhs)
    {
        return lhs.mOriginIterator == rhs.mOriginIterator;
    }
 
    friend bool operator!=(const AdaptedIterator& lhs, const AdaptedIterator& rhs)
    {
        return lhs.mOriginIterator != rhs.mOriginIterator;
    }
 
    template<typename Q = TargetType>
    std::enable_if_t<WithoutCast<Q, SourceType>::value, MakeConstRef_t<value_type>>
    operator*() const
    {
        return *mOriginIterator;
    }
 
    template<typename Q = TargetType>
    std::enable_if_t<WithDynamicCast<Q, SourceType>::value, value_type>
    operator*() const
    {
        const SourceType &value = *mOriginIterator;
        return System::ExplicitCast<typename ReturnTypeTrait<Q>::Pointee>(value);
    }
 
    template<typename Q = TargetType>
    std::enable_if_t<WithUnboxing<Q, SourceType>::value, value_type>
    operator*() const
    {
        const SourceType &value = *mOriginIterator;
        return ObjectExt::Unbox<typename ReturnTypeTrait<Q>::ReturnType>(value);
    }
 
    template<typename Q = TargetType>
    std::enable_if_t<WithBoxing<Q, SourceType>::value, value_type>
    operator*() const
    {
        const SourceType &value = *mOriginIterator;
        return ObjectExt::Box(value);
    }
 
    AdaptedIterator& operator++()
    {
        ++mOriginIterator;
        return *this;
    }
 
private:
    Iterator mOriginIterator;
};
 
template<typename Iterable, typename T>
struct CppIteratorAdapter
{
    CppIteratorAdapter(SmartPtr<Iterable> enumerable) : mEnumerable(std::move(enumerable)) {}
 
    using origin_iterator = decltype(std::declval<Iterable>().begin());
    using iterator = AdaptedIterator<T, origin_iterator>;
 
    iterator begin()
    {
        return iterator(mEnumerable->begin());
    }
 
    iterator end()
    {
        return iterator(mEnumerable->end());
    }
 
private:
    SmartPtr<Iterable> mEnumerable;
};
 
}
 
template<typename T, typename Enumerable>
std::enable_if_t<!Details::IsIterable<Enumerable>::value, Details::EnumeratorAdapter<Enumerable, T>>
IterateOver(System::SmartPtr<Enumerable> enumerable)
{
    return Details::EnumeratorAdapter<Enumerable, T>(std::move(enumerable));
}
 
template<typename Enumerable>
std::enable_if_t<!Details::IsIterable<Enumerable>::value, Details::EnumeratorAdapter<Enumerable>>
IterateOver(System::SmartPtr<Enumerable> enumerable)
{
    return Details::EnumeratorAdapter<Enumerable>(std::move(enumerable));
}
 
template<typename Enumerable>
std::enable_if_t<Details::IsIterable<Enumerable>::value, System::SmartPtr<Enumerable>>
IterateOver(System::SmartPtr<Enumerable> enumerable)
{
    return enumerable;
}
 
template<typename T, typename Enumerable>
std::enable_if_t<Details::IsIterable<Enumerable>::value && std::is_same<typename Details::ReturnTypeTrait<T>::ReturnType, Details::IterableValueType<Enumerable>>::value, System::SmartPtr<Enumerable>>
IterateOver(System::SmartPtr<Enumerable> enumerable)
{
    return enumerable;
}
 
template<typename T, typename Enumerable>
std::enable_if_t<Details::IsIterable<Enumerable>::value && !std::is_same<typename Details::ReturnTypeTrait<T>::ReturnType, Details::IterableValueType<Enumerable>>::value, Details::CppIteratorAdapter<Enumerable, T>>
IterateOver(System::SmartPtr<Enumerable> enumerable)
{
    return Details::CppIteratorAdapter<Enumerable, T>(std::move(enumerable));
}
 
template<typename Enumerable>
std::enable_if_t<!IsSmartPtr<Enumerable>::value, Details::EnumeratorAdapter<Enumerable, Details::ValueTypeOfEnumerable<Enumerable>, Enumerable*>>
IterateOver(const Enumerable* enumerable)
{
    return Details::EnumeratorAdapter<Enumerable, Details::ValueTypeOfEnumerable<Enumerable>, Enumerable*>(const_cast<Enumerable*>(enumerable));
}
 
template<typename T, typename Enumerable>
std::enable_if_t<!IsSmartPtr<Enumerable>::value, Details::EnumeratorAdapter<Enumerable, T, Enumerable*>>
IterateOver(const Enumerable* enumerable)
{
    return Details::EnumeratorAdapter<Enumerable, T, Enumerable*>(const_cast<Enumerable*>(enumerable));
}
 
}