arg_stream.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef ADOBE_ARG_STREAM_H
#define ADOBE_ARG_STREAM_H
 
#include <boost/function_types/function_arity.hpp>
#include <boost/function_types/function_type.hpp>
#include <boost/function_types/result_type.hpp>
 
#include <boost/mpl/begin.hpp>
#include <boost/mpl/deref.hpp>
#include <boost/mpl/end.hpp>
#include <boost/mpl/next.hpp>
 
// Apple sucks
#ifdef nil
#undef nil
#endif
 
#include <boost/fusion/include/cons.hpp>
#include <boost/fusion/include/invoke.hpp>
#include <boost/fusion/include/push_back.hpp>
 
#include <boost/utility/enable_if.hpp>
 
#include <adobe/type_inspection.hpp> // ADOBE_HAS_TYPE/ADOBE_HAS_MEMBER
 
#include <functional>
 
namespace adobe {

 
namespace arg_stream {
 

struct no_more_args : std::exception {};
 
 
namespace detail {
ADOBE_HAS_TYPE_IMPL(eof);
 
template <typename T>
struct has_eof_member {
    static const bool value = ADOBE_HAS_TYPE(T, eof);
};
} // namespace detail

template <typename T>
struct traits {
    static const bool has_eof_member = detail::has_eof_member<T>::value;
};
 
 
namespace detail {
template <class ArgStream>
static bool
eof_check(ArgStream& as,
          typename boost::enable_if_c<traits<ArgStream>::has_eof_memberfunction>::type* dummy = 0) {
    return as.eof();
}
 
template <class ArgStream>
static bool eof_check(
    ArgStream& as,
    typename boost::disable_if_c<traits<ArgStream>::has_eof_memberfunction>::type* dummy = 0) {
    return false;
}
 
template <class ArgStream>
static bool eof_check(ArgStream* as) {
    return as ? eof_check(*as) : true;
}
} // namespace detail

template <typename ArgStream>
bool eof(ArgStream const& as) {
    return detail::eof_check(as);
}

template <typename R, typename ArgStream>
R get_next_arg(ArgStream const& as) {
    return as.get_next_arg<R>();
}
// specialize these or let them fallback to the above specialization
template <typename R, typename ArgStream>
R get_next_arg(ArgStream& as) {
    return as.get_next_arg<R>();
}
template <typename R, typename ArgStream>
R get_next_arg(ArgStream* as) {
    return get_next_arg<R>(*as);
}
template <typename R, typename ArgStream>
R get_next_arg(ArgStream const* as) {
    return get_next_arg<R>(*as);
}
 

template <typename F>
struct signature {
    typedef F type;
};
// specialize for std::function
template <typename F>
struct signature<std::function<F>> {
    typedef F type;
};

template <typename F>
struct result_type {
    typedef typename boost::function_types::result_type<typename signature<F>::type>::type type;
};
 
namespace detail {
// how it all works...
 
 
template <typename T>
struct remove_cv_ref : boost::remove_cv<typename boost::remove_reference<T>::type> {};
 
 
// see also boost::function_types 'interpreter' example
// we convert the function signature into a mpl sequence (it *is* an mpl sequence, since it
// implements mpl::begin/end/etc)
// we recursively push the args onto a fusion sequence, calling get_next_arg as we go.
// the recursion ends when we get to the end of the mpl-sequence-function-sigature
// (see the specialized case where From == To)
// and then luckily fusion has a magic invoke function we can use
template <typename F,
          class From = typename boost::mpl::begin<
              boost::function_types::parameter_types<typename signature<F>::type>>::type,
          class To = typename boost::mpl::end<
              boost::function_types::parameter_types<typename signature<F>::type>>::type>
struct invoker {
    // add an argument to a Fusion cons-list for each parameter type
    template <typename Args, typename ArgStream>
    static inline typename result_type<F>::type apply(F func, ArgStream& astream,
                                                      Args const& args) {
        typedef typename remove_cv_ref<typename boost::mpl::deref<From>::type>::type arg_type;
        typedef typename boost::mpl::next<From>::type next_iter_type;
 
        return invoker<F, next_iter_type, To>::apply(
            func, astream, boost::fusion::push_back(args, get_next_arg<arg_type>(astream)));
    }
};
 
// specialize final case
template <typename F, class To>
struct invoker<F, To, To> {
    template <typename Args, typename ArgStream>
    static inline typename result_type<F>::type apply(F func, ArgStream&, Args const& args) {
        return boost::fusion::invoke(func, args);
    }
};
 
} // namespace detail
 

template <typename F, typename ArgStream>
typename result_type<F>::type call(F f, ArgStream& astream) {
    return detail::invoker<F>::template apply(f, astream, boost::fusion::nil());
}

template <class T, typename F, typename ArgStream>
typename result_type<F>::type call(T* that, F f, ArgStream& astream) {
    // object gets pushed on as first arg of fusion list,
    // and remove first arg from signature (the object that the member function belongs to)
    // using
    // mpl::next
    boost::fusion::nil args;
    return detail::invoker<
        F,
        typename boost::mpl::next<typename boost::mpl::begin<boost::function_types::parameter_types<
            typename signature<F>::type, boost::add_pointer<boost::mpl::placeholders::_>>>::type>::
            type,
        typename boost::mpl::end<boost::function_types::parameter_types<
            typename signature<F>::type, boost::add_pointer<boost::mpl::placeholders::_>>>::type>::
        template apply(f, astream, boost::fusion::push_back(args, that));
}
 

template <typename ArgStreamFirst, typename ArgStreamSecond>
struct chain {
    template <class ArgStream>
    bool eof(ArgStream* as) {
        return detail::eof_check(as);
    }
 
    typedef ArgStreamFirst first_type;
    typedef ArgStreamSecond second_type;
    ArgStreamFirst* first;
    ArgStreamSecond* second;
 
    chain(ArgStreamFirst& first_stream, ArgStreamSecond& second_stream)
        : first(&first_stream), second(&second_stream) {}
 
    template <typename T>
    T get_next_arg() {
        if (!eof(first)) {
            try {
                return first->get_next_arg<T>();
            } catch (arg_stream::no_more_args&) {
                first = 0;
            }
        }
 
        return second->get_next_arg<T>();
    }
 
    bool eof() const { return eof(first) && eof(second); }
};
 
template <typename S1, typename S2>
struct traits<chain<S1, S2>> {
    static const bool has_eof_memberfunction = true;
};

template <typename ArgStreamFirst, typename ArgStreamSecond>
chain<ArgStreamFirst, ArgStreamSecond> make_chain(ArgStreamFirst& first_stream,
                                                  ArgStreamSecond& second_stream) {
    return chain<ArgStreamFirst, ArgStreamSecond>(first_stream, second_stream);
}

struct nonarg {
    bool eof() { return true; }
 
    template <typename R>
    R get_next_arg() {
        throw arg_stream::no_more_args();
 
        return *(R*)32; // some compilers need a return; here's a bad one (but that doesn't require
                        // default construction)
    }
};
 
template <>
struct traits<nonarg> {
    static const bool has_eof_memberfunction = true;
};

template <typename T>
struct single {
    typedef T value_type;
 
    T value;
    unsigned int repeat; // yep, unsigned.
 
    single(typename boost::add_reference<T const>::type t, unsigned int count = 1)
        : value(t), repeat(count) {}
 
    bool eof() { return repeat == 0; }
 
    template <typename R>
    R convert_or_throw(
        value_type& value,
        typename boost::enable_if<boost::is_convertible<value_type, R>>::type* dummy = 0) {
        return R(value);
    }
    template <typename R>
    R convert_or_throw(
        value_type& value,
        typename boost::disable_if<boost::is_convertible<value_type, R>>::type* dummy = 0) {
        throw adobe::bad_cast();
        return *(R*)value;
    }
 
    template <typename R>
    R get_next_arg() {
        if (repeat) {
            repeat--;
        } else {
            throw arg_stream::no_more_args();
        }
 
        return convert_or_throw<R>(value);
    }
};
 
template <typename T>
struct traits<single<T>> {
    static const bool has_eof_memberfunction = true;
};
 
template <typename ArgStream, typename Transformer>
struct with_transform {
    ADOBE_HAS_TEMPLATE1_IMPL(arg_stream_inverse_lookup);
 
    template <typename Class>
    struct has_inverse_lookup {
        static const bool value = ADOBE_HAS_TEMPLATE1(Class, arg_stream_inverse_lookup);
    };
 
    template <typename Class, typename R, bool>
    struct has_entry_if_has_inverse_lookup {
        static const bool value = false;
    };
    template <typename Class, typename R>
    struct has_entry_if_has_inverse_lookup<Class, R, true> {
        static const bool value =
            has_type_type<typename Class::template arg_stream_inverse_lookup<R>>::value;
    };
 
    template <typename Class, typename R>
    struct has_transform {
        static const bool value =
            has_entry_if_has_inverse_lookup<Class, R, has_inverse_lookup<Class>::value>::value;
    };
 
    typedef ArgStream value_type;
    typedef ArgStream arg_stream_type;
    typedef Transformer transformer_type;
 
    ArgStream& argstream;
    Transformer& transformer;
 
    with_transform(ArgStream& as, Transformer& trans) : argstream(as), transformer(trans) {}
 
    bool eof() { return detail::eof_check(argstream); }
 
    template <typename R>
    R transforming_get(typename boost::enable_if<has_transform<Transformer, R>>::type* dummy = 0) {
        typedef typename Transformer::template arg_stream_inverse_lookup<R>::type Rfrom;
        return transformer.template arg_stream_transform<R>(
            arg_stream::get_next_arg<Rfrom>(argstream));
    }
    template <typename R>
    R transforming_get(typename boost::disable_if<has_transform<Transformer, R>>::type* dummy = 0) {
        return arg_stream::get_next_arg<R>(argstream);
    }
 
    template <typename R>
    R get_next_arg() {
        return transforming_get<R>();
    }
};
 
template <typename ArgStream, typename Transformer>
with_transform<ArgStream, Transformer> make_transforming(ArgStream& as, Transformer& transformer) {
    return with_transform<ArgStream, Transformer>(as, transformer);
}
 
} // namespace arg_stream
} // namespace adobe
 
 
#endif // include_guard