ProgressInfo.hpp

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____    _____ __    __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\  |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: InfoPipe
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/BaseValues.h>
#include <NDEVR/TimeSpan.h>
#include <NDEVR/Buffer.h>
namespace NDEVR
{
    class StringView;
    class String;
    class LogStream;
    class LogMessage;
    class TranslatedString;
    class InfoPipe
    {
    public: 
        friend class LogPtr;
        friend class ProgressInfo;
        friend class CancelInfo;
        friend class LogManager;
        InfoPipe() noexcept {};
        virtual ~InfoPipe(){};
        virtual void addMessage(uint04 id, const LogMessage& message) = 0;
        virtual void addMessage(uint04 id, const StringView& message, uint01 log_level = 10) = 0;
        virtual void addMessage(uint04 id, const TranslatedString& message, uint01 log_level = 10) = 0;
        virtual void addMessages(uint04 id, const AlocatingAlignedBuffer<LogMessage, 32>& messages) = 0;
        virtual void addStream(LogStream*, bool) {}
        virtual void removeStream(LogStream*) {}
        virtual bool cancelRequested() const = 0;
        virtual void requestCancel() = 0;
        virtual void requestCancel(uint04) = 0;
        virtual fltp04 progressIdx(uint04) const { return 1.0f; };
        virtual void addInput(const StringView&, uint04) = 0;
        virtual void addInput(const StringView&) = 0;
    protected:
        virtual uint04 addProgressSource(const TranslatedString& name, fltp04 progress) = 0;
        virtual void addProgressSource(const TranslatedString& name, uint04 idx, fltp04 progress) = 0;
        virtual void removeProgressSource(uint04 idx) = 0;
        virtual void setProgressIdx(uint04 idx, fltp04 percent) = 0;
        virtual uint04 addCancelGuard(const TranslatedString& name) = 0;
        virtual void addCancelGuard(const TranslatedString& name, uint04 idx) = 0;
        virtual void removeCancelGuard(uint04 idx) = 0;
        virtual bool cancelRequestedIdx(uint04 idx) const = 0;
 
        virtual uint04 addInputGuard(const TranslatedString& name) = 0;
        virtual void addInputGuard(const TranslatedString& name, uint04 idx) = 0;
        virtual void removeInputGuard(uint04 idx) = 0;
        virtual void getInputIdx(String&, uint04, bool) {};
        virtual void clearInputIdx(uint04) = 0;
    protected:
        static volatile uint04 s_idx_incrementor;//used to generate new idx. Use thread-safe increment
    };

    class LogPtr : public InfoPipe
    {
    public:
        LogPtr() noexcept
            : m_log(nullptr)
            , m_idx(Constant<uint04>::Invalid)
        {}
        LogPtr(InfoPipe* log)
            : m_log(log)
            , m_idx(Constant<uint04>::Invalid)
        {}
        LogPtr(const LogPtr& log)
            : m_log(log.m_log)
            , m_idx(log.m_idx)
        {}
        explicit LogPtr(InfoPipe& log)
            : m_log(&log)
            , m_idx(Constant<uint04>::Invalid)
        {}
        bool isValid() const 
        { 
            return m_log != nullptr; 
        }
        InfoPipe* pipe() const
        {
            return m_log;
        }
        LogPtr& operator=(const LogPtr& log)
        {
            m_log = log.m_log;
            return *this;
        }
        bool operator==(const LogPtr& log) const
        {
            if (m_log == log.m_log && m_idx == log.m_idx)
                return true;
            return false;
        }
        bool operator!=(const LogPtr& log) const
        {
            if (m_log != log.m_log || m_idx != log.m_idx)
                return true;
            return false;
        }
        void addMessage(const LogMessage& message) const
        { 
            if (m_log) 
                return m_log->addMessage(m_idx, message);
        }
        void addMessage(const StringView& message, uint01 log_level = 10) const
        { 
            if (m_log) 
                return m_log->addMessage(m_idx, message, log_level);
        }
        void addMessage(const TranslatedString& message, uint01 log_level = 10) const
        { 
            if (m_log) 
                m_log->addMessage(m_idx, message, log_level);
        }
 
        void addMessages(const AlocatingAlignedBuffer<LogMessage, 32>& messages) const
        {
            if (m_log)
                m_log->addMessages(m_idx, messages);
        }
        void addStream(LogStream* stream, bool add_all) final override
        { 
            if (m_log) m_log->addStream(stream, add_all); 
        }
        void removeStream(LogStream* stream) final override
        {
            if (m_log) m_log->removeStream(stream); 
        }
        void requestCancel() final override
        {
            if (m_log) m_log->requestCancel();
        }
        void requestCancel(uint04 idx) final override 
        { 
            if (m_log) m_log->requestCancel(idx);
        }
        bool cancelRequested() const override
        {
            if (m_log) 
                return m_log->cancelRequested();
            return false;
        }
        fltp04 progressIdx(uint04 idx) const final override
        {
            if (m_log) 
                return m_log->progressIdx(idx);
            return 1.0f;
        }
        void addInput(const StringView& s, uint04 idx) final override
        {
            if (m_log)
                m_log->addInput(s, idx);
        }
        void addInput(const StringView& s) final override
        {
            if (m_log)
                m_log->addInput(s);
        }
    protected:
        virtual void addMessage(uint04 id, const LogMessage& message) final override
        {
            if (m_log)
                m_log->addMessage(id, message);
        }
        virtual void addMessage(uint04 id, const StringView& message, uint01 log_level) final override
        {
            if (m_log)
                m_log->addMessage(id, message, log_level);
        }
        virtual void addMessage(uint04 id, const TranslatedString& message, uint01 log_level) final override
        {
            if (m_log)
                m_log->addMessage(id, message, log_level);
        }
        virtual void addMessages(uint04 id, const AlocatingAlignedBuffer<LogMessage, 32>& messages) final override
        {
            if (m_log)
                m_log->addMessages(id, messages);
        }
        void setProgressIdx(uint04 idx, fltp04 percent) final override
        {
            if (m_log)
                m_log->setProgressIdx(idx, percent);
        }
        virtual uint04 addProgressSource(const TranslatedString& name, fltp04 progress) final override
        {
            if (m_log)
                return m_log->addProgressSource(name, progress);
            return Constant<uint04>::Invalid;
        }
        virtual void addProgressSource(const TranslatedString& name, uint04 idx, fltp04 progress) final override
        {
            if (m_log)
                return m_log->addProgressSource(name, idx, progress);
        }
        void removeProgressSource(uint04 idx) final override
        {
            if (m_log)
                m_log->removeProgressSource(idx);
        }
        uint04 addCancelGuard(const TranslatedString& name) final override
        {
            if (m_log)
                return m_log->addCancelGuard(name);
            return Constant<uint04>::Invalid;
        }
        virtual void addCancelGuard(const TranslatedString& name, uint04 idx) final override
        {
            if (m_log)
                return m_log->addCancelGuard(name, idx);
        }
        void removeCancelGuard(uint04 idx) final override
        {
            if (m_log)
                m_log->removeCancelGuard(idx);
        }
        bool cancelRequestedIdx(uint04 idx) const final override
        {
            if (m_log)
                return m_log->cancelRequestedIdx(idx);
            else
                return false;
        }
        uint04 addInputGuard(const TranslatedString& name) final override
        {
            if (m_log)
                return m_log->addInputGuard(name);
            return Constant<uint04>::Invalid;
        }
        void addInputGuard(const TranslatedString& name, uint04 idx) final override
        {
            if (m_log)
                m_log->addInputGuard(name, idx);
        }
        void removeInputGuard(uint04 idx) final override
        {
            if (m_log)
                m_log->removeInputGuard(idx);
        }
        virtual void getInputIdx(String& s, uint04 idx, bool clear) final override
        {
            if (m_log)
                m_log->getInputIdx(s, idx, clear);
        }
        virtual void clearInputIdx(uint04 idx) final override
        {
            if (m_log)
                m_log->clearInputIdx(idx);
        }
    protected:
        InfoPipe* m_log;
        uint04 m_idx;
    };

    class ProgressInfo : public LogPtr
    {
    public:
        ProgressInfo()
            : LogPtr()
        {}
        ProgressInfo(const TranslatedString& name, InfoPipe* pipe, fltp04 percent = Constant<fltp04>::Invalid)
            : LogPtr(pipe)
        {
            if (pipe)
                pipe->addProgressSource(name, percent);
        }
        ProgressInfo(const TranslatedString& name, const LogPtr& pipe, fltp04 percent = Constant<fltp04>::Invalid)
            : LogPtr(pipe)
        {
            m_idx = LogPtr::addProgressSource(name, percent);
        }
        ProgressInfo(const TranslatedString& name, InfoPipe& pipe, fltp04 percent = Constant<fltp04>::Invalid)
            : LogPtr(pipe)
        {
            m_idx = pipe.addProgressSource(name, percent);
        }
        ProgressInfo(const ProgressInfo& info) = delete;
        ~ProgressInfo()
        {
            LogPtr::setProgressIdx(m_idx, 1.0f);
            LogPtr::removeProgressSource(m_idx);
        }
        void setPipe(InfoPipe* pipe)
        {
            finish();
            m_log = pipe;
        }
        void finish()
        {
            LogPtr::setProgressIdx(m_idx, 1.0f);
            LogPtr::removeProgressSource(m_idx);
            m_idx = Constant<uint04>::Invalid;
        }
        void restart(const TranslatedString& name, fltp04 percent = Constant<fltp04>::Invalid)
        {
            LogPtr::setProgressIdx(m_idx, 1.0f);
            LogPtr::removeProgressSource(m_idx);
            m_idx = LogPtr::addProgressSource(name, percent);
        }
        void restart(const TranslatedString& name, InfoPipe* log, fltp04 percent = Constant<fltp04>::Invalid)
        {
            if (m_log)
                finish();
            m_log = log;
            m_idx = LogPtr::addProgressSource(name, percent);
        }
        void setProgress(fltp04 progress)
        {
            LogPtr::setProgressIdx(m_idx, progress);
        }
        template<class t_type_a>
        void setProgress(const t_type_a& count, const t_type_a& total)
        {
            if(LogPtr::isValid())
                LogPtr::setProgressIdx(m_idx, cast<fltp04>(count) / cast<fltp04>(total));
        }
        template<class t_type_a>
        void setProgressIfNeeded(const t_type_a& count, const t_type_a& total, const t_type_a& epsilon)
        {
            uint08 ucount = cast<uint08>(count);
            if(LogPtr::isValid() && (m_last_progress_set > ucount || m_last_progress_set + epsilon > ucount))
                LogPtr::setProgressIdx(m_idx, cast<fltp04>(count) / cast<fltp04>(total));
        }
        //calculates an epsilon to be used with setProgressIfNeeded 
        template<class t_type_a>
        static t_type_a CalcAbsEpsilon(const t_type_a& total, fltp08 desired_epsilon = 0.01)
        {
            return cast<t_type_a>(cast<fltp08>(total) * desired_epsilon);
        }
        void setProgress(const TimeSpan& count, const TimeSpan& total)
        {
            if (LogPtr::isValid())
                LogPtr::setProgressIdx(m_idx, cast<fltp04>(count / total));
        }
        void setToIndeterminateProgress()
        {
            LogPtr::setProgressIdx(m_idx, Constant<fltp04>::Invalid);
        }
        fltp04 progress() const
        {
            return LogPtr::progressIdx(m_idx);
        }
    protected:
        uint08 m_last_progress_set = Constant<uint08>::Invalid;
    };

    class CancelInfo : public LogPtr
    {
    public:
        CancelInfo()
            : LogPtr()
        {}
        CancelInfo(const TranslatedString& name, InfoPipe* pipe)
            : LogPtr(pipe)
        {
            if (pipe)
                m_idx = pipe->addCancelGuard(name);
        }
        CancelInfo(const TranslatedString& name, const LogPtr& pipe)
            : LogPtr(pipe)
        {
            m_idx = LogPtr::addCancelGuard(name);
        }
        CancelInfo(const TranslatedString& name, InfoPipe& pipe)
            : LogPtr(pipe)
        {
            m_idx = pipe.addCancelGuard(name);
        }
        CancelInfo(const CancelInfo& info) = delete;
        ~CancelInfo()
        {
            LogPtr::removeCancelGuard(m_idx);
        }
        void finish()
        {
            LogPtr::removeCancelGuard(m_idx);
        }
        void setPipe(InfoPipe* pipe)
        {
            finish();
            m_log = pipe;
        }
        void restart(const TranslatedString& name)
        {
            LogPtr::removeCancelGuard(m_idx);
            m_idx = LogPtr::addCancelGuard(name);
        }
        void restart(const TranslatedString& name, InfoPipe* log)
        {
            if (m_log)
                finish();
            m_log = log;
            m_idx = LogPtr::addCancelGuard(name);
        }
        bool cancelRequested() const final override
        {
            if (m_log)
                return m_log->cancelRequestedIdx(m_idx);
            return false;
        }
    };
};