PlatformFactory.cpp

/*
 * Copyright (C) 2021 CERN
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 * Created on: 2021-10-29
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#include "PlatformFactory.hpp"
 
#include <map>
 
#include <ccut/Exception.hpp>
#include <logger/Logger.hpp>
 
#include "Exception.hpp"
#include "MotionLibConfig.hpp"
#include "platform/PlatformBase.hpp"
#include "specialized/GrblPlatform/GrblPlatform.hpp"
#include "specialized/MGrblPlatform/MGrblPlatform.hpp"
#include "specialized/MockPlatform/MockPlatform.hpp"
 
#ifdef PLATFORM_SAMBUCA
#include "specialized/MFEPlatform/MFEPlatform.hpp"
#endif
 
using namespace logger;
namespace yml = ccut::yml;
 
namespace smc {
namespace internal {
 
static const std::string s_loggerCat{"smc:platform"};
static std::map<std::string,
                std::function<PlatformBase::Shared(yml::NodeRef node)>>
    s_registry{{"MockPlatform", MockPlatform::create},
               {"GrblPlatform", GrblPlatform::create},
               {"MGrblPlatform", MGrblPlatform::create},
#ifdef PLATFORM_SAMBUCA
               {"MFEPlatform", MFEPlatform::create}
#endif
    };
 
PlatformFactory::~PlatformFactory()
{
    for (PlatformBase::Shared p : m_platforms)
        p->stop();
}
 
std::size_t PlatformFactory::buildPlatforms(const std::string &platformDesc)
{
    try
    {
        yml::Parser parser;
        yml::Tree tree = parser.parse_in_arena("<yml>",
                                               yml::to_csubstr(platformDesc));
        yml::NodeRef platformsNode = yml::get(tree.rootref(), "platforms");
        return buildPlatforms(platformsNode, &parser);
    }
    catch (std::exception &ex)
    {
        error(s_loggerCat) << "failed to parse platform: " << ex.what();
    }
    return 0;
}
 
std::size_t PlatformFactory::buildPlatforms(const yml::NodeRef &platformsNode,
                                            const yml::Parser *parser)
{
    std::size_t newPlatformCount = 0;
    try
    {
        if (!platformsNode.valid() || !platformsNode.is_seq())
            throw Exception(ErrorCode::InvalidArguments,
                            "platforms description must be an array");
 
        for (yml::NodeRef node : platformsNode)
        {
            std::string type;
            yml::get(node, "type") >> yml::default_to(type, std::string());
            if (type.empty())
            {
                if (parser)
                    throw yml::make_error(*parser, node, "type not found");
                else
                    throw ccut::Exception(ccut::ErrorCode::InvalidArguments,
                                          "type not found");
            }
 
            decltype(s_registry)::const_iterator it = s_registry.find(type);
            if (it == s_registry.end())
                error(s_loggerCat) << "unknown platform: " << type;
            else
            {
                try
                {
                    PlatformBase::Shared platform{(it->second)(node)};
                    {
                        const std::lock_guard<std::mutex> lock{m_platformsMutex};
                        m_platforms.emplace_back(platform);
                    }
                    newPlatformCount++;
                }
                catch (std::exception &ex)
                {
                    error(s_loggerCat)
                        << "failed to create platform: " << ex.what();
                }
            }
        }
    }
    catch (std::exception &ex)
    {
        error(s_loggerCat) << "failed to parse platform: " << ex.what();
    }
    info(s_loggerCat) << newPlatformCount << " platforms created";
    return newPlatformCount;
}
 
std::list<PlatformBase::Shared> PlatformFactory::getPlatforms()
{
    const std::lock_guard<std::mutex> lock{m_platformsMutex};
    std::list<PlatformBase::Shared> newList{m_platforms};
    return newList;
}
 
} /* namespace internal */
} /* namespace smc */