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) {
36
                    std::shared_ptr<variable::Object> object = produceObject(module_name);
37
                    array->values().push_back(object);
38
                }
39
            }
40
    }
41

42
    return array;
43
}
44

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

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

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

66
    _modules.insert({module_name, module_object});
67
    return std::make_shared<variable::Object>(module_object->instantiate(module_object));
68
}
69

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

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

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

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