Initial commit

winx64/include/boost/accumulators/framework/accumulators/droppable_accumulator.hpp

@@ -0,0 +1,328 @@
+///////////////////////////////////////////////////////////////////////////////
+// droppable_accumulator.hpp
+//
+//  Copyright 2005 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)
+
+#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_DROPPABLE_ACCUMULATOR_HPP_EAN_13_12_2005
+#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_DROPPABLE_ACCUMULATOR_HPP_EAN_13_12_2005
+
+#include <new>
+#include <boost/assert.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/aligned_storage.hpp>
+#include <boost/accumulators/framework/depends_on.hpp> // for feature_of
+#include <boost/accumulators/framework/parameters/accumulator.hpp> // for accumulator
+
+namespace boost { namespace accumulators
+{
+
+    template<typename Accumulator>
+    struct droppable_accumulator;
+
+    namespace detail
+    {
+        ///////////////////////////////////////////////////////////////////////////////
+        // add_ref_visitor
+        //   a fusion function object for add_ref'ing accumulators
+        template<typename Args>
+        struct add_ref_visitor
+        {
+            explicit add_ref_visitor(Args const &args)
+              : args_(args)
+            {
+            }
+
+            template<typename Accumulator>
+            void operator ()(Accumulator &acc) const
+            {
+                typedef typename Accumulator::feature_tag::dependencies dependencies;
+
+                acc.add_ref(this->args_);
+
+                // Also add_ref accumulators that this feature depends on
+                this->args_[accumulator].template
+                    visit_if<detail::contains_feature_of_<dependencies> >(
+                        *this
+                );
+            }
+
+        private:
+            add_ref_visitor &operator =(add_ref_visitor const &);
+            Args const &args_;
+        };
+
+        template<typename Args>
+        add_ref_visitor<Args> make_add_ref_visitor(Args const &args)
+        {
+            return add_ref_visitor<Args>(args);
+        }
+
+        ///////////////////////////////////////////////////////////////////////////////
+        // drop_visitor
+        //   a fusion function object for dropping accumulators
+        template<typename Args>
+        struct drop_visitor
+        {
+            explicit drop_visitor(Args const &args)
+              : args_(args)
+            {
+            }
+
+            template<typename Accumulator>
+            void operator ()(Accumulator &acc) const
+            {
+                if(typename Accumulator::is_droppable())
+                {
+                    typedef typename Accumulator::feature_tag::dependencies dependencies;
+
+                    acc.drop(this->args_);
+                    // Also drop accumulators that this feature depends on
+                    this->args_[accumulator].template
+                        visit_if<detail::contains_feature_of_<dependencies> >(
+                            *this
+                    );
+                }
+            }
+
+        private:
+            drop_visitor &operator =(drop_visitor const &);
+            Args const &args_;
+        };
+
+        template<typename Args>
+        drop_visitor<Args> make_drop_visitor(Args const &args)
+        {
+            return drop_visitor<Args>(args);
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // droppable_accumulator_base
+    template<typename Accumulator>
+    struct droppable_accumulator_base
+      : Accumulator
+    {
+        typedef droppable_accumulator_base base;
+        typedef mpl::true_ is_droppable;
+        typedef typename Accumulator::result_type result_type;
+
+        template<typename Args>
+        droppable_accumulator_base(Args const &args)
+          : Accumulator(args)
+          , ref_count_(0)
+        {
+        }
+
+        droppable_accumulator_base(droppable_accumulator_base const &that)
+          : Accumulator(*static_cast<Accumulator const *>(&that))
+          , ref_count_(that.ref_count_)
+        {
+        }
+
+        template<typename Args>
+        void operator ()(Args const &args)
+        {
+            if(!this->is_dropped())
+            {
+                this->Accumulator::operator ()(args);
+            }
+        }
+
+        template<typename Args>
+        void add_ref(Args const &)
+        {
+            ++this->ref_count_;
+        }
+
+        template<typename Args>
+        void drop(Args const &args)
+        {
+            BOOST_ASSERT(0 < this->ref_count_);
+            if(1 == this->ref_count_)
+            {
+                static_cast<droppable_accumulator<Accumulator> *>(this)->on_drop(args);
+            }
+            --this->ref_count_;
+        }
+
+        bool is_dropped() const
+        {
+            return 0 == this->ref_count_;
+        }
+
+    private:
+        int ref_count_;
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+    // droppable_accumulator
+    //   this can be specialized for any type that needs special handling
+    template<typename Accumulator>
+    struct droppable_accumulator
+      : droppable_accumulator_base<Accumulator>
+    {
+        template<typename Args>
+        droppable_accumulator(Args const &args)
+          : droppable_accumulator::base(args)
+        {
+        }
+
+        droppable_accumulator(droppable_accumulator const &that)
+          : droppable_accumulator::base(*static_cast<typename droppable_accumulator::base const *>(&that))
+        {
+        }
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+    // with_cached_result
+    template<typename Accumulator>
+    struct with_cached_result
+      : Accumulator
+    {
+        typedef typename Accumulator::result_type result_type;
+
+        template<typename Args>
+        with_cached_result(Args const &args)
+          : Accumulator(args)
+          , cache()
+        {
+        }
+
+        with_cached_result(with_cached_result const &that)
+          : Accumulator(*static_cast<Accumulator const *>(&that))
+          , cache()
+        {
+            if(that.has_result())
+            {
+                this->set(that.get());
+            }
+        }
+
+        ~with_cached_result()
+        {
+            // Since this is a base class of droppable_accumulator_base,
+            // this destructor is called before any of droppable_accumulator_base's
+            // members get cleaned up, including is_dropped, so the following
+            // call to has_result() is valid.
+            if(this->has_result())
+            {
+                this->get().~result_type();
+            }
+        }
+
+        template<typename Args>
+        void on_drop(Args const &args)
+        {
+            // cache the result at the point this calculation was dropped
+            BOOST_ASSERT(!this->has_result());
+            this->set(this->Accumulator::result(args));
+        }
+
+        template<typename Args>
+        result_type result(Args const &args) const
+        {
+            return this->has_result() ? this->get() : this->Accumulator::result(args);
+        }
+
+    private:
+        with_cached_result &operator =(with_cached_result const &);
+
+        void set(result_type const &r)
+        {
+            ::new(this->cache.address()) result_type(r);
+        }
+
+        result_type const &get() const
+        {
+            return *static_cast<result_type const *>(this->cache.address());
+        }
+
+        bool has_result() const
+        {
+            typedef with_cached_result<Accumulator> this_type;
+            typedef droppable_accumulator_base<this_type> derived_type;
+            return static_cast<derived_type const *>(this)->is_dropped();
+        }
+
+        aligned_storage<sizeof(result_type)> cache;
+    };
+
+    namespace tag
+    {
+        template<typename Feature>
+        struct as_droppable
+        {
+            typedef droppable<Feature> type;
+        };
+
+        template<typename Feature>
+        struct as_droppable<droppable<Feature> >
+        {
+            typedef droppable<Feature> type;
+        };
+
+        //////////////////////////////////////////////////////////////////////////
+        // droppable
+        template<typename Feature>
+        struct droppable
+          : as_feature<Feature>::type
+        {
+            typedef typename as_feature<Feature>::type feature_type;
+            typedef typename feature_type::dependencies tmp_dependencies_;
+
+            typedef
+                typename mpl::transform<
+                    typename feature_type::dependencies
+                  , as_droppable<mpl::_1>
+                >::type
+            dependencies;
+
+            struct impl
+            {
+                template<typename Sample, typename Weight>
+                struct apply
+                {
+                    typedef
+                        droppable_accumulator<
+                            typename mpl::apply2<typename feature_type::impl, Sample, Weight>::type
+                        >
+                    type;
+                };
+            };
+        };
+    }
+
+    // make droppable<tag::feature(modifier)> work
+    template<typename Feature>
+    struct as_feature<tag::droppable<Feature> >
+    {
+        typedef tag::droppable<typename as_feature<Feature>::type> type;
+    };
+
+    // make droppable<tag::mean> work with non-void weights (should become
+    // droppable<tag::weighted_mean>
+    template<typename Feature>
+    struct as_weighted_feature<tag::droppable<Feature> >
+    {
+        typedef tag::droppable<typename as_weighted_feature<Feature>::type> type;
+    };
+
+    // for the purposes of feature-based dependency resolution,
+    // droppable<Foo> provides the same feature as Foo
+    template<typename Feature>
+    struct feature_of<tag::droppable<Feature> >
+      : feature_of<Feature>
+    {
+    };
+
+    // Note: Usually, the extractor is pulled into the accumulators namespace with
+    // a using directive, not the tag. But the droppable<> feature doesn't have an
+    // extractor, so we can put the droppable tag in the accumulators namespace
+    // without fear of a name conflict.
+    using tag::droppable;
+
+}} // namespace boost::accumulators
+
+#endif

winx64/include/boost/accumulators/framework/accumulators/external_accumulator.hpp

@@ -0,0 +1,108 @@
+///////////////////////////////////////////////////////////////////////////////
+// external_accumulator.hpp
+//
+//  Copyright 2005 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)
+
+#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_EXTERNAL_ACCUMULATOR_HPP_EAN_01_12_2005
+#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_EXTERNAL_ACCUMULATOR_HPP_EAN_01_12_2005
+
+#include <boost/mpl/placeholders.hpp>
+#include <boost/parameter/keyword.hpp>
+#include <boost/accumulators/framework/extractor.hpp>
+#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
+#include <boost/accumulators/framework/accumulator_base.hpp>
+#include <boost/accumulators/framework/accumulators/reference_accumulator.hpp>
+
+namespace boost { namespace accumulators { namespace impl
+{
+
+    //////////////////////////////////////////////////////////////////////////
+    // external_impl
+    /// INTERNAL ONLY
+    ///
+    template<typename Accumulator, typename Tag>
+    struct external_impl
+      : accumulator_base
+    {
+        typedef typename Accumulator::result_type result_type;
+        typedef typename detail::feature_tag<Accumulator>::type feature_tag;
+
+        external_impl(dont_care) {}
+
+        template<typename Args>
+        result_type result(Args const &args) const
+        {
+            return this->extract_(args, args[parameter::keyword<Tag>::get() | 0]);
+        }
+
+    private:
+
+        template<typename Args>
+        static result_type extract_(Args const &args, int)
+        {
+            // No named parameter passed to the extractor. Maybe the external
+            // feature is held by reference<>.
+            extractor<feature_tag> extract;
+            return extract(accumulators::reference_tag<Tag>(args));
+        }
+
+        template<typename Args, typename AccumulatorSet>
+        static result_type extract_(Args const &, AccumulatorSet const &acc)
+        {
+            // OK, a named parameter for this external feature was passed to the
+            // extractor, so use that.
+            extractor<feature_tag> extract;
+            return extract(acc);
+        }
+    };
+
+} // namespace impl
+
+namespace tag
+{
+    //////////////////////////////////////////////////////////////////////////
+    // external
+    template<typename Feature, typename Tag, typename AccumulatorSet>
+    struct external
+      : depends_on<reference<AccumulatorSet, Tag> >
+    {
+        typedef
+            accumulators::impl::external_impl<
+                detail::to_accumulator<Feature, mpl::_1, mpl::_2>
+              , Tag
+            >
+        impl;
+    };
+
+    template<typename Feature, typename Tag>
+    struct external<Feature, Tag, void>
+      : depends_on<>
+    {
+        typedef
+            accumulators::impl::external_impl<
+                detail::to_accumulator<Feature, mpl::_1, mpl::_2>
+              , Tag
+            >
+        impl;
+    };
+}
+
+// for the purposes of feature-based dependency resolution,
+// external_accumulator<Feature, Tag> provides the same feature as Feature
+template<typename Feature, typename Tag, typename AccumulatorSet>
+struct feature_of<tag::external<Feature, Tag, AccumulatorSet> >
+  : feature_of<Feature>
+{
+};
+
+// Note: Usually, the extractor is pulled into the accumulators namespace with
+// a using directive, not the tag. But the external<> feature doesn't have an
+// extractor, so we can put the external tag in the accumulators namespace
+// without fear of a name conflict.
+using tag::external;
+
+}} // namespace boost::accumulators
+
+#endif

winx64/include/boost/accumulators/framework/accumulators/reference_accumulator.hpp

@@ -0,0 +1,89 @@
+///////////////////////////////////////////////////////////////////////////////
+// reference_accumulator.hpp
+//
+//  Copyright 2005 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)
+
+#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_REFERENCE_ACCUMULATOR_HPP_EAN_03_23_2006
+#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_REFERENCE_ACCUMULATOR_HPP_EAN_03_23_2006
+
+#include <boost/ref.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/parameter/keyword.hpp>
+#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
+#include <boost/accumulators/framework/accumulator_base.hpp>
+#include <boost/accumulators/framework/extractor.hpp>
+
+namespace boost { namespace accumulators
+{
+
+namespace impl
+{
+    //////////////////////////////////////////////////////////////////////////
+    // reference_accumulator_impl
+    //
+    template<typename Referent, typename Tag>
+    struct reference_accumulator_impl
+      : accumulator_base
+    {
+        typedef Referent &result_type;
+
+        template<typename Args>
+        reference_accumulator_impl(Args const &args)
+          : ref(args[parameter::keyword<Tag>::get()])
+        {
+        }
+
+        result_type result(dont_care) const
+        {
+            return this->ref;
+        }
+
+    private:
+        reference_wrapper<Referent> ref;
+    };
+} // namespace impl
+
+namespace tag
+{
+    //////////////////////////////////////////////////////////////////////////
+    // reference_tag
+    template<typename Tag>
+    struct reference_tag
+    {
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+    // reference
+    template<typename Referent, typename Tag>
+    struct reference
+      : depends_on<>
+    {
+        /// INTERNAL ONLY
+        ///
+        typedef mpl::always<accumulators::impl::reference_accumulator_impl<Referent, Tag> > impl;
+    };
+}
+
+namespace extract
+{
+    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, reference, (typename)(typename))
+    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, reference_tag, (typename))
+}
+
+using extract::reference;
+using extract::reference_tag;
+
+// Map all reference<V,T> features to reference_tag<T> so
+// that references can be extracted using reference_tag<T>
+// without specifying the referent type.
+template<typename ValueType, typename Tag>
+struct feature_of<tag::reference<ValueType, Tag> >
+  : feature_of<tag::reference_tag<Tag> >
+{
+};
+
+}} // namespace boost::accumulators
+
+#endif

winx64/include/boost/accumulators/framework/accumulators/value_accumulator.hpp

@@ -0,0 +1,89 @@
+///////////////////////////////////////////////////////////////////////////////
+// value_accumulator.hpp
+//
+//  Copyright 2005 Eric Niebler, Daniel Egloff. 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)
+
+#ifndef BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_VALUE_ACCUMULATOR_HPP_EAN_03_23_2006
+#define BOOST_ACCUMULATORS_FRAMEWORK_ACCUMULATORS_VALUE_ACCUMULATOR_HPP_EAN_03_23_2006
+
+#include <boost/mpl/always.hpp>
+#include <boost/parameter/keyword.hpp>
+#include <boost/accumulators/framework/depends_on.hpp> // for feature_tag
+#include <boost/accumulators/framework/accumulator_base.hpp>
+#include <boost/accumulators/framework/extractor.hpp>
+
+namespace boost { namespace accumulators
+{
+
+namespace impl
+{
+
+    //////////////////////////////////////////////////////////////////////////
+    // value_accumulator_impl
+    template<typename ValueType, typename Tag>
+    struct value_accumulator_impl
+      : accumulator_base
+    {
+        typedef ValueType result_type;
+
+        template<typename Args>
+        value_accumulator_impl(Args const &args)
+          : val(args[parameter::keyword<Tag>::get()])
+        {
+        }
+
+        result_type result(dont_care) const
+        {
+            return this->val;
+        }
+
+    private:
+        ValueType val;
+    };
+
+} // namespace impl
+
+namespace tag
+{
+    //////////////////////////////////////////////////////////////////////////
+    // value_tag
+    template<typename Tag>
+    struct value_tag
+    {
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+    // value
+    template<typename ValueType, typename Tag>
+    struct value
+      : depends_on<>
+    {
+        /// INTERNAL ONLY
+        ///
+        typedef mpl::always<accumulators::impl::value_accumulator_impl<ValueType, Tag> > impl;
+    };
+}
+
+namespace extract
+{
+    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, value, (typename)(typename))
+    BOOST_ACCUMULATORS_DEFINE_EXTRACTOR(tag, value_tag, (typename))
+}
+
+using extract::value;
+using extract::value_tag;
+
+// Map all value<V,T> features to value_tag<T> so
+// that values can be extracted using value_tag<T>
+// without specifying the value type.
+template<typename ValueType, typename Tag>
+struct feature_of<tag::value<ValueType, Tag> >
+  : feature_of<tag::value_tag<Tag> >
+{
+};
+
+}} // namespace boost::accumulators
+
+#endif