lagoon/utils.hpp

Go to the documentation of this file.

#ifndef LAGOON_UTILS_1011291729_HPP
#define LAGOON_UTILS_1011291729_HPP

#include <lagoon/lagoon_fwd.hpp>
#include <lagoon/range/fwd_decl.hpp>
#include <vector>
#include <cassert>

LAGOON_NAMESPACE_BEGIN

template <typename MetaObject> class shared;

namespace aux {

// helper function used for getting to the wrapped raw pointer inside
// of a shared<MetaObject> in internal code
// NOTE: this is an implementation detail, never use this function in
// client code
template <typename MetaObject>
MetaObject* _get_mo(const shared<MetaObject>&);

} // namespace aux


template <typename MetaObject>
class shared
{
private:
    MetaObject* mo;

    MetaObject* get(void) const
    {
        return mo;
    }

    friend MetaObject* aux::_get_mo<>(const shared<MetaObject>&);
public:
    inline shared(void)
     : mo(nullptr)
    { }

    explicit inline shared(MetaObject* p)
     : mo(p)
    { }

    template <class OtherMO>
    inline shared(const shared<OtherMO>& other)
     : mo(aux::_get_mo(other))
    { }

    inline operator bool (void) const
    {
        return mo != nullptr;
    }

    inline bool operator ! (void) const
    {
        return mo == nullptr;
    }

    inline MetaObject* operator -> (void) const
    {
        assert(mo != nullptr);
        return mo;
    }


    template <class Interface>
    shared<Interface> as(void) const
    {
        // try to cast to the specified interface
#if MIRROR_NO_RTTI
        Interface* imo = static_cast<Interface*>(get()->cast_to(
            categorize_interface((Interface*)nullptr)
        ));
#else
        Interface* imo = dynamic_cast<Interface*>(get());
#endif
        // wrap the raw pointer and return it
        return shared<Interface>(imo);
    }


    template <class Interface>
    bool is(void) const
    {
        return mo->self()->is_a(categorize_interface(
            (Interface*)nullptr
        ));
    }
};

namespace aux {

template <typename MetaObject>
inline MetaObject* _get_mo(const shared<MetaObject>& shared_mo)
{
    return shared_mo.get();
}

} // namespace aux



template <class SharedMetaObject>
struct shared_meta_object;

// Implementation of the shared_meta_object trait
template <class MetaObject>
struct shared_meta_object<shared<MetaObject> >
{
    typedef MetaObject type;
};

template <typename MetaObject>
class range;


template <typename MetaObject, class Iterator>
class range_base
{
protected:
    typedef Iterator iterator;
    iterator current, end;
    friend class lagoon::aux::std_range_adapt<range<MetaObject> >;
public:

    inline range_base(const iterator& b, const iterator& e)
     : current(b)
     , end(e)
    { }

    inline bool empty(void) const
    {
        return end == current;
    }

    inline size_t size(void) const
    {
        return end - current;
    }

    void step_front(void)
    {
        assert(!empty());
        ++current;
    }


    size_t leap_front(size_t leap)
    {
        if(leap > size())
        {
            current = end;
            return size();
        }
        else
        {
            current += leap;
            return leap;
        }
    }

    const shared<MetaObject>& front(void) const
    {
        assert(!empty());
        return *current;
    }

    shared<MetaObject> at(size_t offs) const
    {
        assert(offs < size());
        return *(current + offs);
    }

    friend bool same_position(const range_base& a, const range_base& b)
    {
        return a.current == b.current;
    }
};


template <typename MetaObject>
class range : public range_base<
    MetaObject,
    typename std::vector<shared<MetaObject> >::const_iterator
>
{
private:
    typedef range_base<
        MetaObject,
        typename std::vector<shared<MetaObject> >::const_iterator
    > base_class;
    typedef typename base_class::iterator iterator;
    friend class lagoon::aux::std_range_adapt<range<MetaObject> >;
public:
    // TODO: replace this when inherited constructors become supported
    inline range(const iterator& b, const iterator& e)
     : base_class(b, e)
    { }
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Range>
struct range_meta_object
{
    typedef unspecified type;
};
#else
template <typename Range>
struct range_meta_object
{
private:
    static Range& dummy_range(void);
public:
    typedef typename shared_meta_object<
        decltype(dummy_range().front())
    >::type type;
};
#endif

template <typename MetaObject>
struct range_meta_object<range<MetaObject> >
{
    typedef MetaObject type;
};

LAGOON_NAMESPACE_END

#endif //include guard