#include <utility>
#include <boost/iterator/filter_iterator.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/fusion/sequence.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/mpl/if.hpp>




namespace boost {

namespace qlang {



namespace fields {

template <int N>
struct placeholder {
    static const int value = N;
};


placeholder<0> full_object;
placeholder<1>  _1;
placeholder<2>  _2;
placeholder<3>  _3;
placeholder<4>  _4;
placeholder<5>  _5;
placeholder<6>  _6;



} //namespace fields



namespace detail {


template <class FusionSequence, class Placeholder>
struct field_select {
    typedef boost::tuple<typename boost::fusion::result_of::value_at_c<FusionSequence, Placeholder::value - 1>::type> result_type;

    result_type operator()(const FusionSequence & val) const { 
        return boost::make_tuple(boost::fusion::at_c<Placeholder::value - 1>(val));
    }
};



template <class Range, class Predicate, class Placeholder> 
struct filtered_range_type : boost::mpl::if_
                                <boost::is_same<fields::placeholder<0>, Placeholder>,
                                    boost::iterator_range<
                                    boost::filter_iterator<Predicate, 
                                    typename Range::const_iterator> >
                                    , 
                                    boost::iterator_range<
                                    boost::transform_iterator<detail::field_select<typename Range::value_type, Placeholder>,
                                    boost::filter_iterator<Predicate, typename Range::const_iterator> > >
                                >
{};



} //namespace detail




template <class Range>
class from_;

template <class Range, class Predicate>
class where_;


template <class Range, class Predicate, class Placeholder>
class select_;


template <class Range, class Predicate, class Placeholder>
class select_ {
    const Range & range_;
    typedef typename detail::filtered_range_type<Range, Predicate, Placeholder>::type filtered_range;
    Predicate pred_;
    filtered_range frange_;

public:
    typedef typename Range::value_type value_type;

public:

    typename filtered_range::const_iterator begin(); 
    typename filtered_range::const_iterator end();
    

    select_(const Range & rng, Predicate && pred) : range_(rng),
        pred_(std::forward<Predicate>(pred)),
        frange_(boost::make_filter_iterator(pred_, range_.begin(), range_.end()),
                                 boost::make_filter_iterator(pred_,
                                 range_.end(), range_.end())) {}

};



template <class Range, class Predicate>
class where_ {
private:
    const Range & range_;
    Predicate pred_;

  
public:
    
    where_(const Range & range, Predicate && pred) : 
        range_(range),
        pred_(std::forward<Predicate>(pred)) {
    }

   
    template <class Placeholder>
    select_<Range, Predicate, Placeholder>
    select(Placeholder & p);

            
    Predicate get_predicate() const { return pred_; }
};


template <class Range>
class from_ {
private:    
    const Range & range_;
public:
    typedef Range range_type;
    typedef typename Range::value_type value_type;

    from_(const Range & r) : range_(r) {}

    template <class Predicate>
    where_<Range, Predicate> where(Predicate && pred) {
        return where_<Range, Predicate>(range_, std::move(pred));
    }
};


template <class Range>
from_<Range> from(const Range & r) {
    return from_<Range>(r);
}



template <class Range, class Predicate>
template <class Placeholder>
select_<Range, Predicate, Placeholder>
where_<Range, Predicate>::select(Placeholder & p)
{
    return select_<Range, Predicate, Placeholder>(this->range_, std::move(this->get_predicate()));
}



template <class Range, class Predicate, class Placeholder>
typename select_<Range, Predicate, Placeholder>::filtered_range::const_iterator 
select_<Range, Predicate, Placeholder>::begin()
{ 
    this->frange_ = filtered_range(boost::make_filter_iterator(pred_, range_.begin(), range_.end()),
                             boost::make_filter_iterator(pred_, range_.end(),   range_.end()));
    return frange_.begin();
}


template <class Range, class Predicate, class Placeholder>
typename select_<Range, Predicate, Placeholder>::filtered_range::const_iterator 
select_<Range, Predicate, Placeholder>::end()
{ 
    return this->frange_.end();
}



} //namespace boost

} //namespace qlang