loom

1
/*
2
MIT License
3

4
Copyright (c) 2021 МГТУ им. Н.Э. Баумана, кафедра ИУ-6, Михаил Фетисов,
5

6
https://bmstu.codes/lsx/simodo/stars
7
*/
8

9
#include "simodo/module/ModuleCollector.h"
10
#include "simodo/module/HardModuleLoader.h"
11
#include "simodo/inout/convert/functions.h"
12
#include "simodo/inout/format/fmt.h"
13

14
#include <filesystem>
15

16
using namespace simodo;
17
using namespace simodo::module;
18

19
namespace fs = std::filesystem;
20

21
ModuleCollector::ModuleCollector(std::vector<std::string> module_places)
22
    : _module_places(module_places)
23
{}
24

25
std::shared_ptr<variable::Array> ModuleCollector::produceObjectsByMask(const std::string & module_mask)
26
{
27
    std::shared_ptr<variable::Array> array = std::make_shared<variable::Array>();
28

29
    for(fs::path path : _module_places) {
30
        if (!fs::exists(path))
31
            continue;
32
        for (auto const & dir_entry : fs::directory_iterator{path})
33
            if (dir_entry.path().extension() == ".simodo-module") {
34
                std::string module_name = dir_entry.path().stem().string();
35
                if (module_name.substr(0,module_mask.size()) == module_mask) // -V1051
36
                {
37
                    std::shared_ptr<variable::Object> object = produceObject(module_name);
38
                    array->add(object);
39
                }
40
            }
41
    }
42

43
    return array;
44
}
45

46
std::shared_ptr<variable::Object> ModuleCollector::produceObject(const std::string & module_name,
47
                    interpret::Interpret_interface * interpret)
48
{
49
    _last_error = "";
50

51
    auto it = _modules.find(module_name);
52
    if (it != _modules.end())
53
        return it->second->instantiate(it->second).getObject();
54
    
55
    std::shared_ptr<variable::Module_interface> module_object = HardModuleLoader(_module_places).load(module_name,interpret);
56
    if (!module_object) {
57
        _last_error = inout::fmt("Unable to create module '%1'").arg(module_name);
58
        return {};
59
    }
60

61
    version_t v = module_object->version();
62
    if (v.major() != LibVersion_Major || v.minor() > LibVersion_Minor) {
63
        _last_error = inout::fmt("Incorrect version of module '%1'").arg(module_name);
64
        return {};
65
    }
66

67
    _modules.insert({module_name, module_object});
68
    return module_object->instantiate(module_object).getObject();
69
}
70

71
variable::Value ModuleCollector::invoke(variable::Object & object, const std::string & method_name, const variable::VariableSet_t & arguments)
72
{
73
    _last_error = "";
74

75
    const variable::Variable & function = object.getVariableByName(inout::toU16(method_name));
76
    if (function.type() == variable::ValueType::Null) {
77
        _last_error = inout::fmt("Member '%1' not found").arg(method_name);
78
        return {};
79
    }
80

81
    if (function.type() != variable::ValueType::Function) {
82
        _last_error = inout::fmt("Member '%1' is not a function").arg(method_name);
83
        return {};
84
    }
85

86
    return object.invoke(inout::toU16(method_name), arguments);
87
}
88