events.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//nag_algorithms/events.hpp is free software: you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation, either version 3 of the License, or
//(at your option) any later version.
//
//nag_algorithms/events.hpp is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with nag_algorithms/events.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) Bertini2 Development Team
//
// See <http://www.gnu.org/licenses/> for a copy of the license,
// as well as COPYING.  Bertini2 is provided with permitted
// additional terms in the b2/licenses/ directory.

 
#pragma once
 
#include "bertini2/detail/events.hpp"
#include "bertini2/detail/observable.hpp"   // Observable: the executing tracker is carried as one
#include "bertini2/common/config.hpp"       // SuccessCode: how a completed path ended
 
#include <cstddef>
 
namespace bertini {
 
    namespace algorithm {

        ADD_BERTINI_EVENT_TYPE(AlgorithmEvent, ConstEvent);

        ADD_BERTINI_EVENT_TYPE(AlgorithmStarted, AlgorithmEvent);

        ADD_BERTINI_EVENT_TYPE(AlgorithmComplete, AlgorithmEvent);
 

        template<class ObservedT>
        class PathStarted : public AlgorithmEvent<ObservedT>
        { BOOST_TYPE_INDEX_REGISTER_CLASS
        public:
            using HeldT = typename AlgorithmEvent<ObservedT>::HeldT;
            PathStarted(HeldT obs, std::size_t path_index, Observable const* tracker = nullptr)
                : AlgorithmEvent<ObservedT>(obs), path_index_(path_index), tracker_(tracker)
            {}

            std::size_t PathIndex() const { return path_index_; }

            Observable const* Tracker() const { return tracker_; }
 
            virtual ~PathStarted() = default;
            PathStarted() = delete;
        private:
            std::size_t path_index_;
            Observable const* tracker_ = nullptr;
        };

        template<class ObservedT>
        class PathComplete : public AlgorithmEvent<ObservedT>
        { BOOST_TYPE_INDEX_REGISTER_CLASS
        public:
            using HeldT = typename AlgorithmEvent<ObservedT>::HeldT;
            PathComplete(HeldT obs, std::size_t path_index, Observable const* tracker = nullptr,
                         SuccessCode outcome = SuccessCode::Success)
                : AlgorithmEvent<ObservedT>(obs), path_index_(path_index), tracker_(tracker),
                  outcome_(outcome)
            {}

            std::size_t PathIndex() const { return path_index_; }

            Observable const* Tracker() const { return tracker_; }

            SuccessCode Outcome() const { return outcome_; }
 
            virtual ~PathComplete() = default;
            PathComplete() = delete;
        private:
            std::size_t path_index_;
            Observable const* tracker_ = nullptr;
            SuccessCode outcome_ = SuccessCode::Success;
        };
 
    } // namespace algorithm
 
} // namespace bertini