ResultGroup.h

Go to the documentation of this file.

//***************************************************************************************
//***************************************************************************************
 
#pragma once
 
#include "NAGASH/Global.h"
#include "NAGASH/Result.h"
#include "NAGASH/Toolkit.h"
#include "NAGASH/MapTool.h"
#include "NAGASH/SystTool.h"
 
namespace NAGASH
{
    class ResultGroup
    {
    public:
        ResultGroup(std::shared_ptr<MSGTool> MSG, std::shared_ptr<ConfigTool> c) : config(c), maptool(MSG), msg(MSG) {}
        ResultGroup() = delete;
        ~ResultGroup() = default;
 
        void AddResult(std::shared_ptr<Result> result);
        void Merge(std::shared_ptr<ResultGroup> subGroup);
        void Write();
 
        template <typename R, typename... Args>
        std::shared_ptr<R> BookResult(const TString &name, const TString &fname = "", Args &&...args);
        template <typename R>
        std::shared_ptr<R> Get(const TString &name);
 
    private:
        std::map<TString, std::shared_ptr<Result>> ResultMap;
        std::shared_ptr<ConfigTool> config;
        MapTool maptool;
        std::shared_ptr<MSGTool> msg;
    };
 
    template <typename R, typename... Args>
    inline std::shared_ptr<R> ResultGroup::BookResult(const TString &rname, const TString &fname, Args &&...args)
    {
        static_assert(!std::is_pointer<R>::value, "class ResultGroup: Can not book result in pointer type");
        static_assert(std::is_base_of<Result, R>::value, "class ResulGroup: Input type must be or be inherited from Result class");
 
        auto result = std::make_shared<R>(msg, config, rname, fname, std::forward<Args>(args)...);
 
        if (ResultMap.find(rname) != ResultMap.end())
        {
            msg->StartTitle("ResultGroup::BookResult");
            msg->MSG(MSGLevel::WARNING, "Result ", rname, " already exists, this book will be ignored and return null");
            msg->EndTitle();
            return nullptr;
        }
        else
        {
            ResultMap.emplace(std::pair<TString, std::shared_ptr<Result>>(rname, std::dynamic_pointer_cast<R>(result)));
            return result;
        }
    }
 
    template <typename R>
    inline std::shared_ptr<R> ResultGroup::Get(const TString &name)
    {
        static_assert(!std::is_pointer<R>::value, "class ResultGroup: Can not book result in pointer type");
        static_assert(std::is_base_of<Result, R>::value, "class ResultGroup: Input type must be or be inherited from Result class");
 
        auto titleguard = msg->StartTitleWithGuard("ResultGroup::Get");
        std::shared_ptr<R> result = nullptr;
        auto findresult = maptool.FindMostSimilar(ResultMap, name);
        if (findresult != ResultMap.end())
            result = std::dynamic_pointer_cast<R>(findresult->second);
        if (result == nullptr)
            msg->MSG(MSGLevel::ERROR, "the input key ", name, " not found, returning nullptr");
 
        return result;
    }
 
} // namespace NAGASH