// A stripped down version of FOREACH for
// illustration purposes. NOT FOR GENERAL USE.
// For a complete implementation, see BOOST_FOREACH at
// http://boost-sandbox.sourceforge.net/vault/index.php?directory=eric_niebler
//
// Copyright 2004 Eric Niebler.
// 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)

#include <vector>
#include <iostream>
#include <boost/variant.hpp>

#if defined(_MSC_VER) & _MSC_VER <= 1400
#error Sorry, this doesn''t work on VC++. Try gcc.
#endif

///////////////////////////////////////////////////////////////////////////////
// ENCODED_TYPEOF

template<typename T>
struct type2type {};

template<typename T>
type2type<T> encode_type(T const&) { return type2type<T>(); }

struct any_type
{
    template<typename T>
    operator type2type<T> () const { return type2type<T>(); }
};

#define ENCODED_TYPEOF(expr) (true? any_type() : encode_type(expr))

///////////////////////////////////////////////////////////////////////////////
// EVAL

struct rvalue_probe
{
    template<class T>
    rvalue_probe(T const& t, bool& b)
        : ptemp(const_cast<T*>(&t))
        , is_rvalue(b)
    {}

    template<class R> operator R()
    {
        is_rvalue = true;
        return *static_cast<R*>(ptemp);
    }

    template<class L> operator L&() const
    {
        is_rvalue = false;
        return *static_cast<L*>(ptemp);
    }

    void* ptemp;
    bool& is_rvalue;
};

#define EVAL(expr,is_rvalue) (true? rvalue_probe(expr,is_rvalue) : (expr))

///////////////////////////////////////////////////////////////////////////////
// auto_any

struct auto_any_base
{
    operator bool() const { return false; }
};

template<typename T>
struct auto_any : auto_any_base
{
    auto_any(T const& t) : item(t) {}
    mutable T item;
};

template<typename T>
T& auto_any_cast(auto_any_base const& any)
{
    return static_cast<auto_any<T> const&>(any).item;
}

///////////////////////////////////////////////////////////////////////////////
// FOREACH helper function

template<typename T>
auto_any<boost::variant<T const*,T> >
contain(T const& t, bool const& is_rvalue)
{
    typedef boost::variant<T const*,T> variant_t;
    return is_rvalue ? variant_t(t) : variant_t(&t);
}

template<typename T>
auto_any<typename T::const_iterator>
begin(auto_any_base const& container, bool is_rvalue, type2type<T>)
{
    typedef boost::variant<T const*,T> variant_t;
    variant_t& var = auto_any_cast<variant_t>(container);
    T const& t = is_rvalue ? boost::get<T>(var) : *boost::get<T const*>(var);
    return t.begin();
}

template<typename T>
auto_any<typename T::const_iterator>
end(auto_any_base const& container, bool is_rvalue, type2type<T>)
{
    typedef boost::variant<T const*,T> variant_t;
    variant_t& var = auto_any_cast<variant_t>(container);
    T const& t = is_rvalue ? boost::get<T>(var) : *boost::get<T const*>(var);
    return t.end();
}

template<typename T>
bool done(auto_any_base const& cur, auto_any_base const& end, type2type<T>)
{
    typedef typename T::const_iterator iter_type;
    return auto_any_cast<iter_type>(cur) == auto_any_cast<iter_type>(end);
}

template<typename T>
void next(auto_any_base const& cur, type2type<T>)
{
    typedef typename T::const_iterator iter_type;
    ++auto_any_cast<iter_type>(cur);
}

template<typename T>
typename T::const_reference deref(auto_any_base const& cur, type2type<T>)
{
    typedef typename T::const_iterator iter_type;
    return *auto_any_cast<iter_type>(cur);
}

///////////////////////////////////////////////////////////////////////////////
// FOREACH

#define FOREACH(item, container)                                                        \
    if(bool is_rvalue = false) {} else                                                  \
    if(auto_any_base const& c = contain(EVAL(container,is_rvalue),is_rvalue)) {} else   \
    if(auto_any_base const& b = begin(c,is_rvalue,ENCODED_TYPEOF(container))) {} else   \
    if(auto_any_base const& e = end(c,is_rvalue,ENCODED_TYPEOF(container))) {} else     \
    for(bool more = true;                                                               \
        more && !done(b,e,ENCODED_TYPEOF(container));                                   \
        more ? next(b,ENCODED_TYPEOF(container)) : (void)0)                             \
        if (more = false) {} else                                                       \
        for(item = deref(b,ENCODED_TYPEOF(container)); !more; more = true)


std::vector<double> get_cont()
{
    std::cout << "here\n";
    return std::vector<double>(3,1.0);
}

int main()
{
    FOREACH(double d, get_cont())
    {
        std::cout << d << '\n';
    }

    return 0;
}