#ifndef ACCU_A_INCLUDED
#define ACCU_A_INCLUDED
#include <boost/parameter/keyword.hpp>
#include <boost/mpl/void.hpp>
#include <boost/accumulators/framework/accumulator_base.hpp>
#include <boost/accumulators/framework/extractor.hpp>
#include <boost/accumulators/framework/depends_on.hpp>

namespace boost { namespace accumulators {

namespace tag{
    struct kwd_value_;
}
namespace{
    template<typename Id>
    struct  kwd{
        static ::boost::parameter::keyword<tag::kwd_value_>& value;
    };
    template<typename Id>
    ::boost::parameter::keyword<tag::kwd_value_>&
        kwd<Id>::value = ::boost::parameter::keyword<tag::kwd_value_>::get();

}

namespace impl
{
    ////////////////////////////////////////////////////////////////////////////
    // accu_a_impl
    template<typename Sample,typename Id>
    class accu_a_impl
      : public accumulator_base
    {
    public:
        typedef Sample result_type;
        template<typename Args>
        accu_a_impl(Args const &args)
        :x_(
            args[kwd<Id>::value]
        )
        {
        }

        accu_a_impl(const accu_a_impl& that)
        :x_(that.x_){}

        accu_a_impl& operator=(const accu_a_impl& that){
            if(&that!=this){
                x_ = that.x_;
            }
            return *this;
        }


        template<typename Args>
        void operator ()(Args const &args)
        {

		}

        result_type result(dont_care) const
        {
          return x_;
        }

    private:
	   result_type x_;
    };

} // namespace impl

///////////////////////////////////////////////////////////////////////////////
// tag::accu_a
//

namespace tag
{
    template <typename Id = mpl::void_>
    struct accu_a
      : depends_on<>
    {
        /// INTERNAL ONLY
      typedef accumulators::impl::accu_a_impl<mpl::_1,Id> impl;

    };
}


}} // namespace boost::accumulators

#endif