#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include <boost/phoenix/phoenix.hpp>
#include <boost/function.hpp>
#include <boost/optional.hpp>
#include <boost/any.hpp>


using namespace std;

typedef boost::any attribute_value;
typedef map< string, attribute_value > attribute_values_view;

namespace tag
{
    template<class T>
    struct attr
    {
        typedef T value_type;

        char const* const name;
    };
}

struct get_attr
{
    template <typename Sig>
    struct result;

    template <typename This, typename Attr, typename Env>
    struct result<This(Attr&, Env&)>
    {
        typedef boost::optional<typename Attr::value_type> type;
    };

    template <typename T, typename Env>
    boost::optional<T>
    operator()(tag::attr<T> const& a, Env const& env) const
    {
        attribute_values_view const& view = ::boost::fusion::at_c<0>(env.args());
        attribute_values_view::const_iterator it(view.find(a.name));
        if (it != view.end())
            if (T const* p = boost::any_cast<T>(&it->second))
                return *p;
        return boost::optional<T>();
    }
};

BOOST_PHOENIX_DEFINE_CUSTOM_TERMINAL(
    template <class T>
  , ::tag::attr<T>
  , mpl::false_
  , get_attr(proto::_, functional::env(proto::_state))
)

struct get_value_or_impl
{
    template <typename Sig>
    struct result;

    template <typename This, typename T, typename A>
    struct result<This(boost::optional<T>, A)>
    {
        typedef T const& type;
    };

    template <typename T, typename A>
    T const& operator()(boost::optional<T> const& o, A const& val) const
    {
        return o.get_value_or(val);
    }
};

template< typename DescriptorT >
struct attribute_keyword
  : ::boost::phoenix::actor<DescriptorT>
{
    typedef attribute_keyword this_type;

    template<class T>
    typename boost::phoenix::detail::expression::function_eval
    <get_value_or_impl, this_type, T>::type
    or_default(T const& val) const
    {
        return boost::phoenix::detail::expression::function_eval
            <get_value_or_impl, this_type, T>::make(
                get_value_or_impl(), *this, val);
    }
};


#define BOOST_LOG_REGISTER_ATTRIBUTE( string, name, type ) \
::boost::phoenix::actor< ::tag::attr<type> > name##_base = {{string}};\
attribute_keyword< ::tag::attr<type> >& name\
    = static_cast<attribute_keyword< ::tag::attr<type> >&>(name##_base);


typedef boost::function< bool (attribute_values_view const&) > filter;

enum my_severity { info, warning, error };

BOOST_LOG_REGISTER_ATTRIBUTE("Severity", severity, my_severity)

int main(int argc, char *argv[])
{
    {
        filter flt = severity >= warning;
        attribute_values_view a;
        a["Severity"] = error;
        cout << flt(a) << endl;
    }
    cout << "-----------------\n";
    {
        attribute_values_view const a;
        cout << severity.or_default(info)(a) << endl;
    }

    return EXIT_SUCCESS;
}