StatusSetter.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2022 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program 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 in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * StatusSetter.hpp
 *
 * Allows the receiving function to update the status of the current thread.
 *
 *  Created on: Aug 2, 2020
 *      Author: ans
 */

#ifndef STRUCT_STATUSSETTER_HPP_
#define STRUCT_STATUSSETTER_HPP_

#include "../Helper/CommaLocale.hpp"

#include <cstddef>      // std::size_t
#include <functional>   // std::function
#include <ios>          // std::fixed
#include <sstream>      // std::ostringstream
#include <string>       // std::string
#include <utility>      // std::move

namespace crawlservpp::Struct {


    inline constexpr auto precisionProgress{2};

    inline constexpr auto percentageFactor{100};


    struct StatusSetter {

        std::string currentStatus;


        float progressAfter;


        std::function<void(const std::string&)> callbackSetStatus;

        std::function<void(float)> callbackSetProgress;

        std::function<bool()> callbackIsRunning;



        StatusSetter(
                const std::string& setCurrentStatus,
                float setProgressAfter,
                std::function<void(const std::string&)> callbackToSetStatus,
                std::function<void(float)> callbackToSetProgress,
                std::function<bool()> callbackToCheckIsRunning
        ) :     currentStatus(setCurrentStatus),
                progressAfter(setProgressAfter),
                callbackSetStatus(std::move(callbackToSetStatus)),
                callbackSetProgress(std::move(callbackToSetProgress)),
                callbackIsRunning(std::move(callbackToCheckIsRunning)) {
            if(this->callbackIsRunning()) {
                this->callbackSetStatus(this->currentStatus);
                this->callbackSetProgress(0.F);
            }
        }


        bool change(const std::string& statusMessage) { //NOLINT(modernize-use-nodiscard)
            this->currentStatus = statusMessage;
            this->callbackSetStatus(statusMessage);

            this->callbackSetProgress(0.F);

            return this->callbackIsRunning();
        }


        bool update(std::size_t done, std::size_t total) const { //NOLINT(modernize-use-nodiscard)
            std::ostringstream statusStrStr;

            statusStrStr.imbue(Helper::CommaLocale::locale());

            statusStrStr << this->currentStatus;
            statusStrStr << " [";
            statusStrStr << done;
            statusStrStr << "/";
            statusStrStr << total;
            statusStrStr << "]";

            this->callbackSetStatus(statusStrStr.str());
            this->callbackSetProgress(static_cast<float>(done) / total);

            return this->callbackIsRunning();
        }


        bool update(float percentage, bool precise) const { //NOLINT(modernize-use-nodiscard)
            std::ostringstream statusStrStr;

            if(precise) {
                statusStrStr.precision(precisionProgress);
            }
            else {
                statusStrStr.precision(0);
            }

            statusStrStr << this->currentStatus;
            statusStrStr << " [";
            statusStrStr << std::fixed << percentage * percentageFactor;
            statusStrStr << "%]";

            this->callbackSetStatus(statusStrStr.str());
            this->callbackSetProgress(percentage);

            return this->callbackIsRunning();
        }


        bool update(std::size_t done, std::size_t total, bool precise) const { //NOLINT(modernize-use-nodiscard)
            return this->update(static_cast<float>(done) / total, precise);
        }


        [[nodiscard]] bool isRunning() const {
            return this->callbackIsRunning();
        }

        void finish() const {
            this->callbackSetStatus(this->currentStatus + " [done]");
            this->callbackSetProgress(this->progressAfter);
        }
    };

} /* namespace crawlservpp::Struct */

#endif /* STRUCT_STATUSSETTER_HPP_ */