enum struct operation_t
{
    increment,
    decrement,
    advance,
    equal,
    distance,
    dereference
};

using manager_t = void (*) (operation_t, const boost::any &, const void *, void *);

template <typename Iterator, typename Difference>
void manage (operation_t todo, const boost::any & first, const void * second, void * result)
{
    using value_type = iterator_value_t<Iterator>;
    switch (todo)
    {
        case operation_t::increment:
        {
            assert(second == nullptr);
            assert(result == nullptr);
            ++boost::any_cast<Iterator &>(const_cast<boost::any &>(first));
            break;
        }
        case operation_t::decrement:
        {
            assert(second == nullptr);
            assert(result == nullptr);
            --boost::any_cast<Iterator &>(const_cast<boost::any &>(first));
            break;
        }
        case operation_t::advance:
        {
            assert(result == nullptr);
            using std::advance;
            advance(boost::any_cast<Iterator &>(const_cast<boost::any &>(first)), *static_cast<const Difference *>(second));
            break;
        }
        case operation_t::equal:
        {
            *static_cast<bool *>(result) = (boost::any_cast<const Iterator &>(first) == boost::any_cast<const Iterator &>(*static_cast<const boost::any *>(second)));
            break;
        }
        case operation_t::distance:
        {
            using std::distance;
            *static_cast<Difference *>(result) =
                distance(boost::any_cast<const Iterator &>(first), boost::any_cast<const Iterator &>(*static_cast<const boost::any *>(second)));
            break;
        }
        case operation_t::dereference:
        {
            assert(second == nullptr);
            *static_cast<const value_type **>(result) = std::addressof(*boost::any_cast<const Iterator &>(first));
            break;
        }
    }
}

template <typename Value, typename Category>
class any_iterator:
    public boost::iterator_facade
    <
        any_iterator<Value, Category>,
        Value,
        typename boost::iterator_category_to_traversal<Category>::type,
        Value &
    >
{
private:
    using base_type =
        boost::iterator_facade
        <
            any_iterator<Value, Category>,
            Value,
            typename boost::iterator_category_to_traversal<Category>::type,
            Value &
        >;

public:
    template <typename Iterator>
    explicit any_iterator (Iterator i):
        m_iterator(std::move(i)),
        m_manager(&manage<Iterator, typename base_type::difference_type>)
    {
    }

    any_iterator () = default;

private:
    friend class boost::iterator_core_access;

    void increment ()
    {
        m_manager(operation_t::increment, m_iterator, nullptr, nullptr);
    }

    void decrement ()
    {
        m_manager(operation_t::decrement, m_iterator, nullptr, nullptr);
    }

    void advance (typename base_type::difference_type n)
    {
        m_manager(operation_t::advance, m_iterator, std::addressof(n), nullptr);
    }

    bool equal (const any_iterator & that) const
    {
        assert(this->m_manager == that.m_manager);
        bool are_equal;
        m_manager(operation_t::equal, m_iterator, std::addressof(that), std::addressof(are_equal));
        return are_equal;
    }

    typename base_type::difference_type distance_to (const any_iterator & that) const
    {
        assert(this->m_manager == that.m_manager);
        typename base_type::difference_type distance;
        m_manager(operation_t::distance, m_iterator, std::addressof(that), std::addressof(distance));
        return distance;
    }

    typename base_type::reference dereference () const
    {
        typename base_type::value_type * pointer;
        m_manager(operation_t::dereference, m_iterator, nullptr, std::addressof(pointer));
        return *pointer;
    }

private:
    boost::any m_iterator;
    manager_t m_manager;
};

template <typename Value, typename Category>
using any_range = boost::iterator_range<any_iterator<Value, Category>>;