#include <boost/spirit/phoenix/actor.hpp>
#include <boost/spirit/phoenix/operators.hpp>

#include <boost/function.hpp>
#include <boost/program_options.hpp>
using namespace boost;
using namespace boost::program_options;

#include <iostream>
using namespace std;

class exists_t
{
public:

    template<class TupleT>
    struct result { typedef bool type; };

    exists_t(const std::string& name)
    : m_name(name) {}

    template <typename TupleT>
    bool
    eval(TupleT const& args) const
    {
        bool v = args[phoenix::tuple_index<0>()].count(m_name);
        std::cout << m_name << " : " << v << "\n";
        return v;
    }

private:
    std::string m_name;
};

// For some reason, we can't define 'exists_t' from
// actor<exists_t>. The compiler say 'exists_t' is incomplete.
phoenix::actor<exists_t>
exists(const std::string& name)
{
    return exists_t(name);
}

int main(int ac, char* av[])
{
    options_description d;
    d.add_options()
        ("foo", value<int>(), "")
        ("bar", value<int>(), "")
        ;
    
    boost::program_options::variables_map vm;
    store(parse_command_line(ac, av, d), vm);
    notify(vm);

    boost::function<bool (variables_map&)> f = 
        exists("foo") || exists("bar");
    if (f(vm))
    {
        cout << "OK\n";
    } 
    else 
    {
        cout << "Not OK\n";
    }
}