mdd/lib/src/ProcessorBase.cpp

#include "ProcessorBase.h"

namespace mdd{
    ProcessorBase::ProcessorBase(const std::string& base_config)
    : _base_config(base_config)
    {

    }

    bool ProcessorBase::configure(const std::string& config) {
        json j = json::parse(config);
        for (size_t i = 0; i < j.size(); i++)
        {
            if (j.contains("params"))
            {
                if (j["params"].contains("inputs"))
                {
                    for (size_t i = 0; i < j["inputs"].size(); i++)
                    {
                        inputs.push_back(std::make_shared<Parameter>(this));
                        inputs.back()->setName(j["inputs"][i]["type"].get<std::string>());
                        inputs.back()->setAppendix(j["inputs"][i]["appendix"].get<int>());
                    }
                }
                if (j["params"].contains("outputs"))
                {
                    for (size_t i = 0; i < j["outputs"].size(); i++)
                    {
                        outputs.push_back(std::make_shared<Parameter>(this));
                        outputs.back()->setName(j["outputs"][i]["type"].get<std::string>());
                        outputs.back()->setAppendix(j["outputs"][i]["appendix"].get<int>());
                    }
                }
            }
            
            if (j.contains("modules")) {
                auto regi = Registration();
                for (size_t i = 0; i < j["modules"].size(); i++)
                {
                    addModule(regi.generateModule(j["modules"][i]["id"].get<std::string>()));
                    modules.back()->setName(j["modules"][i]["type"].get<std::string>());
                    modules.back()->setAppendix(j["modules"][i]["appendix"].get<int>());
                    modules.back()->load(j["modules"][i]["load"]);
                }
            }
            if (j.contains("connections")) {
                for (size_t i = 0; i < j["connections"].size(); i++)
                {
                    connect(j["connections"][i]["output"].get<std::string>(), j["connections"][i]["inputs"].get<std::vector<std::string>>());
                }
            }
        }
        return true;
    }

    std::string ProcessorBase::getConfiguration() {
        //update module apendix ?

        json ret = json::parse(_base_config);
        json sub_ret;
        sub_ret["params"];
        sub_ret["params"]["inputs"];
        for (size_t i = 0; i < inputs.size(); i++)
        {
            json sub;
            sub["type"] = inputs[i]->getType();
            sub["appendix"] = inputs[i]->getAppendix();
            sub_ret["params"]["inputs"].push_back(sub);
        }

        sub_ret["params"]["outputs"];
        for (size_t i = 0; i < outputs.size(); i++)
        {
            json sub;
            sub["type"] = outputs[i]->getType();
            sub["appendix"] = outputs[i]->getAppendix();
            sub_ret["params"]["outputs"].push_back(sub);
        }

        sub_ret["modules"];
        sub_ret["connections"];
        for (size_t i = 0; i < modules.size(); i++)
        {
            json sub;
            sub["id"] = typeid((*modules[i])).name();
            sub["type"] = modules[i]->getType();
            sub["appendix"] = modules[i]->getAppendix();
            sub["configure"] = modules[i]->dump();
            sub_ret["modules"].push_back(sub);
            for (size_t j = 0; j < modules[i]->getNumOutputs(); j++)
            {
                auto connections = modules[i]->getOutput(j)->getConnections();
                if (!connections.empty())
                {
                    json connect;
                    connect["output"] = modules[i]->getOutput(j)->getParentID() + "/" + modules[i]->getOutput(j)->getID();
                    for (size_t k = 0; k < connections.size(); k++)
                    {
                        connect["inputs"].push_back(connections[k]->getParentID() + "/" + connections[k]->getID());
                    }
                    sub_ret["connections"].push_back(connect);
                }
            }
        }
        ret.push_back(sub_ret);
        return ret.dump();
    }

    std::string ProcessorBase::getType() {
        return  type;
    }

    std::string ProcessorBase::getGeneratorKey() {
        return  key;
    }

    std::string ProcessorBase::setName(const std::string& name) {
        _name = name;
        return getID();
    }

    std::string ProcessorBase::getName() {
        return  _name;
    }

    std::string ProcessorBase::setAppendix(int appendix) {
        _appendix = appendix;
        return  getID();
    }

    int ProcessorBase::getAppendix() {
        return _appendix;
    }

    std::string ProcessorBase::getID() {
        return _name + std::to_string(_appendix);
    }


    std::string ProcessorBase::addModule(std::shared_ptr<IModule> module){
        modules.emplace_back(module);
        modules.back()->setAppendix(modules.size()-1);
        return modules.back()->getID();
    }

    void ProcessorBase::removeModule(std::shared_ptr<IModule> module)
    {

        for (auto it = modules.begin(); it != modules.end(); ++it) {
            if ((*it) == module)
            {
                modules.erase(it);
            }
        }
    }

    std::vector<std::shared_ptr<Parameter>>& ProcessorBase::getInputParams() {
        return inputs;
    }

    std::vector<std::shared_ptr<Parameter>>& ProcessorBase::getOutputParams() {
        return outputs;
    }

    size_t ProcessorBase::getNumInputs() {
        return processor_inputs.size() + inputs.size();
    }

    size_t ProcessorBase::getNumOutputs() {
        return processor_outputs.size() + outputs.size();
    }
    std::vector< std::shared_ptr<IModule >>& ProcessorBase::getModules(){
        return modules;
    }

    size_t ProcessorBase::getNumModuls() {
        return modules.size();
    }

    std::shared_ptr<IModule> ProcessorBase::getModule(size_t index) {
        if (index < modules.size())
        {
            return modules[index];
        }
        return nullptr;
    }

    bool ProcessorBase::connect(const std::string& output_id, const std::vector<std::string>& input_ids)
    {
        std::size_t found = output_id.find_first_of("/");
        std::string str_module_id = output_id.substr(0, found);
        std::string str_output_id = output_id.substr( found + 1);
        std::shared_ptr<IOutput> out_ptr;
        if (str_module_id.empty())
        {
            out_ptr = getOutput(str_output_id);
        }
        else {
            for (size_t i = 0; i < modules.size(); i++)
            {
                if (modules[i]->getID() == str_module_id)
                {
                    out_ptr = modules[i]->getOutput(str_output_id);
                    break;
                }
            }
        }

        for (size_t i = 0; i < input_ids.size(); i++)
        {
            found = input_ids[i].find_first_of("/");
            str_module_id = input_ids[i].substr(0, found);
            std::string str_input_id = input_ids[i].substr(found + 1);

            if (str_module_id.empty())
            {
                auto in_ptr = getInput(str_input_id);
                in_ptr->connect(out_ptr);
            }
            else {
                for (size_t i = 0; i < modules.size(); i++)
                {
                    if (modules[i]->getID() == str_module_id)
                    {
                        auto in_ptr = modules[i]->getInput(str_input_id);
                        in_ptr->connect(out_ptr);
                        break;
                    }
                }
            }
        }
        return true;
    }

    void ProcessorBase::disconnect() {
        for (size_t i = 0; i < processor_inputs.size(); i++)
        {
            processor_inputs[i]->disconnect();
        }
        for (size_t i = 0; i < processor_outputs.size(); i++)
        {
            processor_outputs[i]->disconnect();
        }
        for (size_t i = 0; i < inputs.size(); i++)
        {
            inputs[i]->disconnect();
        }
        for (size_t i = 0; i < outputs.size(); i++)
        {
            outputs[i]->disconnect();
        }
    }

    void ProcessorBase::load(const json& j) {
        
    }

    json ProcessorBase::dump() {
        json ret;
        ret["name"] = _name;
        ret["id"] = getAppendix();
        ret["type"] = type;
        ret["key"] = key;
        ret["prefix"] = std::vector<std::string>();
        ret["configure"] = json::parse(_base_config);
        

        for (auto& in : processor_inputs)
        {
            ret["inputs"].push_back(in->dump());
        }
        for (auto& in : inputs)
        {
            ret["inputs"].push_back(in->getInput(0)->dump());
        }

        for (auto& out : processor_outputs)
        {
            ret["outputs"].push_back(out->dump());
        }
        for (auto& out : outputs)
        {
            ret["outputs"].push_back(out->getInput(0)->dump());
        }
        for (auto& mod : modules)
        {
            ret["modules"].push_back(mod->dump());
        }
        return ret;
    }

    std::shared_ptr<IOutput> ProcessorBase::getOutput(size_t index) {
        if (index < processor_outputs.size())
        {
            return processor_outputs[index];
        }
        index -= processor_outputs.size();
        if (index < outputs.size())
        {
            return outputs[index]->getOutput(0);
        }
        return nullptr;
    }

    std::vector<std::shared_ptr<IInput>> ProcessorBase::getOptimizableInputs() {
        std::vector<std::shared_ptr<IInput>> ret;
        for (size_t i = 0; i < processor_inputs.size(); i++)
        {
            if (processor_inputs[i]->isOptimizable())
            {
                ret.push_back(processor_inputs[i]);
            }
        }
        for (size_t i = 0; i < inputs.size(); i++)
        {
            auto list = inputs[i]->getOptimizableInputs();
            ret.insert(ret.end(), list.begin(), list.end());
        }
        for (size_t i = 0; i < modules.size(); i++)
        {
            auto list = modules[i]->getOptimizableInputs();
            ret.insert(ret.end(), list.begin(), list.end());
        }
        return ret;
    }

    std::vector<std::shared_ptr<IOutput>> ProcessorBase::getOptimizableOutputs() {
        std::vector<std::shared_ptr<IOutput>> ret;
        for (size_t i = 0; i < processor_outputs.size(); i++)
        {
            if (processor_outputs[i]->isOptimizable())
            {
                ret.push_back(processor_outputs[i]);
            }
        }
        for (size_t i = 0; i < outputs.size(); i++)
        {
            auto list = outputs[i]->getOptimizableOutputs();
            ret.insert(ret.end(), list.begin(), list.end());
        }
        for (size_t i = 0; i < modules.size(); i++)
        {
            auto list = modules[i]->getOptimizableOutputs();
            ret.insert(ret.end(), list.begin(), list.end());
        }
        return ret;
    }
   
    std::shared_ptr<IOutput> ProcessorBase::getOutput(const std::string& id){
        for (auto& output : processor_outputs) {
            if(output->getID() == id){
                return output;
            }
        }
        for (auto& output : outputs) {
            if(output->getOutput(0)->getID() == id){
                return output->getOutput(0);
            }
        }
        return nullptr;
    }

    std::shared_ptr<IInput> ProcessorBase::getInput(size_t index) {
        if (index < processor_inputs.size())
        {
            return processor_inputs[index];
        }
        index -= processor_inputs.size();
        if (index < inputs.size())
        {
            return inputs[index]->getInput(0);
        }
        return nullptr;
    }

    std::shared_ptr<IInput> ProcessorBase::getInput(const std::string& id){
        for (auto& input : processor_inputs) {
            if(input->getID() == id){
                return input;
            }
        }
        for (auto& input : inputs) {
            if (input->getInput(0)->getID() == id) {
                return input->getInput(0);
            }
        }
        return nullptr;
    }

    std::shared_ptr<IModule> ProcessorBase::getModule(const std::string& id){
        for (auto& module : modules) {
            if(module->getID() == id){
                return module;
            }
        }
        return nullptr;
    }


}
//*/