loom

1
#include "simodo/lsp-client/SimodoCommandResult.h"
2

3
#include "simodo/inout/convert/functions.h"
4

5
namespace simodo::lsp
6
{
7
    namespace
8
    {
9
        bool parseSimodoCommandReport(const variable::Value & report_value, SimodoCommandReport & report)
10
        {
11
            if (report_value.type() != variable::ValueType::Object) 
12
                return false;
13

14
            std::shared_ptr<variable::Object> report_object = report_value.getObject();
15

16
            const variable::Value & id_value    = report_object->find(u"id");
17
            const variable::Value & title_value = report_object->find(u"title");
18
            const variable::Value & type_value  = report_object->find(u"type");
19
            const variable::Value & text_value  = report_object->find(u"text");
20

21
            if (id_value.type() == variable::ValueType::String)
22
                report.id = id_value.getString();
23
            if (title_value.type() == variable::ValueType::String)
24
                report.title = title_value.getString();
25
            if (type_value.type() == variable::ValueType::Int)
26
                report.type = static_cast<SimodoCommandReportType>(type_value.getInt());
27
            if (text_value.type() == variable::ValueType::String)
28
                report.text = inout::decodeSpecialChars(text_value.getString());
29

30
            return true;
31
        }
32
    }
33

34
    std::vector<SimodoCommandReport> parseSimodoCommandResult(const variable::Value & result_value)
35
    {
36
        std::vector<SimodoCommandReport> res;
37

38
        if (result_value.type() == variable::ValueType::Object) {
39
            SimodoCommandReport report;
40
            if (parseSimodoCommandReport(result_value, report))
41
                res.push_back(report);
42
            return res;
43
        }
44

45
        if (result_value.type() != variable::ValueType::Array)
46
            return res;
47

48
        std::shared_ptr<variable::Array> result_array = result_value.getArray();
49

50
        for(const variable::Value & report_value : result_array->values()) {
51
            SimodoCommandReport report;
52
            if (parseSimodoCommandReport(report_value, report))
53
                res.push_back(report);
54
        }
55

56
        return res;
57
    }
58

59
    bool parseSimodoCommandResult(const simodo::variable::Value & result_value, SimodoCommandResult & result)
60
    {
61
        if (result_value.type() != variable::ValueType::Object) 
62
            return false;
63

64
        std::shared_ptr<variable::Object> result_object = result_value.getObject();
65

66
        const variable::Value & uri_value           = result_object->find(u"uri");
67
        const variable::Value & commandResult_value = result_object->find(u"commandResult");
68

69
        if (uri_value.type() == variable::ValueType::String)
70
            result.uri = uri_value.getString();
71

72
        result.commandResult = parseSimodoCommandResult(commandResult_value);
73

74
        return true;
75
    }
76
}
77