StepCollection.hpp

Go to the documentation of this file.

// This file is part of GQCG-GQCP.
//
// Copyright (C) 2017-2020  the GQCG developers
//
// GQCG-GQCP is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GQCG-GQCP 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GQCG-GQCP.  If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
 
#include "Mathematical/Algorithm/Step.hpp"
#include "Utilities/memory.hpp"
#include "Utilities/type_traits.hpp"
 
#include <boost/format.hpp>
 
#include <vector>
 
 
namespace GQCP {
 
 
template <typename _Environment>
class StepCollection: public Step<_Environment> {
public:
    using Environment = _Environment;
 
 
private:
    std::vector<std::shared_ptr<Step<Environment>>> steps;  // the consecutive steps that this collection consists of
 
 
public:
    /*
     *  PUBLIC OVERRIDDEN METHODS
     */
 
    std::string description() const override {
 
        std::string description_string = (boost::format("An algorithmic step consisting of %s algorithmic steps:\n") % this->numberOfSteps()).str();
 
        for (size_t i = 0; i < this->numberOfSteps(); i++) {
            const auto& step = this->steps[i];
            description_string += (boost::format("\t%s. %s\n") % std::to_string(i + 1) % step->description()).str();
        }
        return description_string;
    }
 
 
    void execute(Environment& environment) override {
        for (const auto& step : this->steps) {
            step->execute(environment);
        }
    }
 
 
    /*
     *  PUBLIC METHODS
     */
 
    template <typename Z = Step<Environment>>
    enable_if_t<std::is_same<Environment, typename Z::Environment>::value, StepCollection<Environment>&> add(const Z& step) {
        this->steps.push_back(std::make_shared<Z>(step));
        return *this;
    }
 
 
    template <typename Z = Step<Environment>>
    enable_if_t<std::is_same<Environment, typename Z::Environment>::value, void> insert(const Z& step, const size_t index) {
 
        // Check if the index is out of bounds.
        if (index > this->numberOfSteps()) {
            throw std::invalid_argument("StepCollection::insert(const Z&, const size_t): Cannot insert at the given index.");
        }
 
 
        // Actually insert in the std::vector of steps.
        if (index < this->numberOfSteps()) {  // within the current bounds
            const auto it = this->steps.begin();
            this->steps.insert(it + index, std::make_shared<Z>(step));  // inserting at an given index goes through an iterator
        }
 
        else if (index == this->numberOfSteps()) {  // at the end
            this->add(step);
        }
    }
 
 
    size_t numberOfSteps() const { return this->steps.size(); }
 
 
    void remove(const size_t index) {
        this->steps.erase(this->steps.begin() + index);
    }
 
 
    template <typename Z = Step<Environment>>
    enable_if_t<std::is_same<Environment, typename Z::Environment>::value, void> replace(const Z& step, const size_t index) {
        this->steps[index] = std::make_shared<Z>(step);
    }
};
 
 
}  // namespace GQCP