StdUtil.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Math/Numeral.h"
#include "Honey/Misc/Range.h"
#include "Honey/Memory/UniquePtr.h"

namespace honey
{



template<class StdContainer>
int size(const StdContainer& cont)                      { return numeric_cast<int>(cont.size()); }

template<class Range>
auto keys(Range&& range) -> Range_<TupleIter<mt_iterOf(range),0>, TupleIter<mt_iterOf(range),0>>
{
    return honey::range(TupleIter<mt_iterOf(range),0>(begin(range)), TupleIter<mt_iterOf(range),0>(end(range)));
}

template<class Range>
auto values(Range&& range) -> Range_<TupleIter<mt_iterOf(range),1>, TupleIter<mt_iterOf(range),1>>
{
    return honey::range(TupleIter<mt_iterOf(range),1>(begin(range)), TupleIter<mt_iterOf(range),1>(end(range)));
}

namespace stdutil
{
    template<class Iter>
    auto reverseIterToForward(Iter&& it) -> typename mt::removeRef<decltype(--it.base())>::type
                                                        { return --it.base(); }

    template<class List>
    typename List::reverse_iterator erase(List& list, const typename List::reverse_iterator& iter)
    {
        return typename List::reverse_iterator(list.erase(reverseIterToForward(iter)));
    }

    template<class List>
    typename List::iterator eraseVal(List& list, const typename List::value_type& val)
    {
        auto it = std::find(list.begin(), list.end(), val);
        if (it == list.end()) return list.end();
        return list.erase(it);
    }

    template<class List, class T>
    void eraseVals(List& list, const T& val)
    {
        auto it = list.begin();
        while((it = std::find(it, list.end(), val)) != list.end())
            it = list.erase(it);
    }

    template<class MultiMap, class Key, class Val>
    auto findVal(MultiMap& map, const Key& key, const Val& val) -> mt_iterOf(map)
    {
        return honey::find(range(map.equal_range(key)), [&](auto& e) { return e.second == val; });
    }
    template<class MultiSet, class Val>
    auto findVal(MultiSet& set, const Val& val) -> mt_iterOf(set)
    {
        return honey::find(range(set.equal_range(val)), [&](auto& e) { return e == val; });
    }

    template<class Key, class Value, template<class> class Alloc>
    using unordered_map = std::unordered_map<Key, Value, std::hash<Key>, std::equal_to<Key>, Alloc<pair<const Key, Value>>>;
    template<class Key, class Value, template<class> class Alloc>
    using unordered_multimap = std::unordered_multimap<Key, Value, std::hash<Key>, std::equal_to<Key>, Alloc<pair<const Key, Value>>>;
    template<class Key, template<class> class Alloc>
    using unordered_set = std::unordered_set<Key, std::hash<Key>, std::equal_to<Key>, Alloc<Key>>;
    template<class Key, template<class> class Alloc>
    using unordered_multiset = std::unordered_multiset<Key, std::hash<Key>, std::equal_to<Key>, Alloc<Key>>;
}

namespace priv
{
    template<szt Arity> struct bind_fill;

    #define PARAMT(It)          , class T##It
    #define PARAM(It)           , T##It&& a##It
    #define ARG(It)             , forward<T##It>(a##It)
    #define PLACE(It)           , _##It

    #define OP(It, ItMax)                                                                               \
        template<class Func ITERATE__(1,It,PARAMT)>                                                     \
        auto operator()(Func&& f ITERATE__(1,It,PARAM)) ->                                              \
            decltype(   bind(forward<Func>(f) ITERATE__(1,It,ARG)                                       \
                            IFEQUAL(It,ItMax,,ITERATE__(1,PP_SUB(ItMax,It),PLACE))) )                   \
        {                                                                                               \
            return      bind(forward<Func>(f) ITERATE__(1,It,ARG)                                       \
                            IFEQUAL(It,ItMax,,ITERATE__(1,PP_SUB(ItMax,It),PLACE)));                    \
        }                                                                                               \
    
    #define STRUCT(It)                                                                                  \
        template<> struct bind_fill<It>     { ITERATE1_(0, It, OP, It) };                               \

    ITERATE(0, 9, STRUCT)
    #undef PARAMT
    #undef PARAM
    #undef ARG
    #undef PLACE
    #undef OP
    #undef STRUCT
}

template<class Func, class... Args>
auto bind_fill(Func&& f, Args&&... args) ->
    decltype(   priv::bind_fill<mt::funcTraits<typename mt::removeRef<Func>::type>::arity>()(forward<Func>(f), forward<Args>(args)...))
{
    return      priv::bind_fill<mt::funcTraits<typename mt::removeRef<Func>::type>::arity>()(forward<Func>(f), forward<Args>(args)...);
}


template<class T, class Ptr = T*, class ConstPtr = const T*>
class deref_wrap
{
public:
    deref_wrap(Ptr ptr = nullptr)                   : _ptr(ptr) {}
    T& operator*()                                  { assert(_ptr); return *_ptr; }
    const T& operator*() const                      { assert(_ptr); return *_ptr; }
    T* operator->()                                 { assert(_ptr); return _ptr; }
    const T* operator->() const                     { assert(_ptr); return _ptr; }
    operator T&()                                   { assert(_ptr); return *_ptr; }
    operator const T&() const                       { assert(_ptr); return *_ptr; }
    bool operator==(const deref_wrap& rhs) const    { return _ptr == rhs._ptr; }
    bool operator!=(const deref_wrap& rhs) const    { return !operator==(rhs); }
    Ptr& ptr()                                      { return _ptr; }
    const ConstPtr& ptr() const                     { return reinterpret_cast<const ConstPtr&>(_ptr); }
private:
    Ptr _ptr;
};


template<class T, class Alloc = typename DefaultAllocator<T>::type>
class recursive_wrap
{
public:
    recursive_wrap(Alloc a = Alloc())                       : _ptr(new (a.allocate(1)) T, move(a)) {}
    template<class T_>
    recursive_wrap(T_&& t, Alloc a = Alloc())               : _ptr(new (a.allocate(1)) T(forward<T_>(t)), move(a)) {}
    recursive_wrap(const recursive_wrap& rhs)               : _ptr(new (const_cast<Alloc&>(rhs._ptr.finalizer().a).allocate(1)) T(*rhs), rhs._ptr.finalizer()) {}
    recursive_wrap(recursive_wrap& rhs)                     : _ptr(new (rhs._ptr.finalizer().a.allocate(1)) T(*rhs), rhs._ptr.finalizer()) {}
    recursive_wrap(recursive_wrap&& rhs)                    : _ptr(move(rhs._ptr)) {}
    
    template<class T_>
    recursive_wrap& operator=(T_&& t)                       { **this = forward<T_>(t); return *this; }
    recursive_wrap& operator=(const recursive_wrap& rhs)    { **this = *rhs; return *this; }
    recursive_wrap& operator=(recursive_wrap& rhs)          { **this = *rhs; return *this; }
    recursive_wrap& operator=(recursive_wrap&& rhs)         { _ptr = move(rhs._ptr); return *this; }
    
    T& operator*()                                          { assert(_ptr); return *_ptr; }
    const T& operator*() const                              { assert(_ptr); return *_ptr; }
    T* operator->()                                         { assert(_ptr); return _ptr; }
    const T* operator->() const                             { assert(_ptr); return _ptr; }
    operator T&()                                           { assert(_ptr); return *_ptr; }
    operator const T&() const                               { assert(_ptr); return *_ptr; }
    T* ptr()                                                { return _ptr; }
    const T* ptr() const                                    { return _ptr; }
    
private:
    UniquePtr<T, finalize<T, Alloc>> _ptr;
};

template<class Subclass>
class Manip
{
public:
    static bool hasInst(ios_base& ios)                                  { return ios.pword(pword); }
    static Subclass& inst(ios_base& ios)
    {
        if (!hasInst(ios)) { ios.pword(pword) = new Subclass(); ios.register_callback(&Manip::delete_, 0); }
        return *static_cast<Subclass*>(ios.pword(pword));
    }
    
private:
    static void delete_(ios_base::event ev, ios_base& ios, int)         { if (ev == ios_base::erase_event) honey::delete_(&inst(ios)); }
    static const int pword;
};
template<class Subclass> const int Manip<Subclass>::pword = ios_base::xalloc();

template<class Func, class Tuple>
struct ManipFunc
{
    template<class Func_, class Tuple_>
    ManipFunc(Func_&& f, Tuple_&& args)                                 : f(forward<Func_>(f)), args(forward<Tuple_>(args)) {}
    
    template<class Stream>
    friend Stream& operator<<(Stream& os, const ManipFunc& manip)       { manip.apply(os, mt::make_idxseq<tuple_size<Tuple>::value>()); return os; }
    template<class Stream>
    friend Stream& operator>>(Stream& is, const ManipFunc& manip)       { manip.apply(is, mt::make_idxseq<tuple_size<Tuple>::value>()); return is; }
    
    template<class Stream, szt... Seq>
    void apply(Stream& ios, mt::idxseq<Seq...>) const                   { f(ios, get<Seq>(args)...); }
    
    Func f;
    Tuple args;
};

template<class Func, class... Args>
inline auto manipFunc(Func&& f, Args&&... args)             { return ManipFunc<Func, decltype(make_tuple(forward<Args>(args)...))>(forward<Func>(f), make_tuple(forward<Args>(args)...)); }


}