StudioSlab/Lib/Utils/PythonUtils.cpp at main · jstreibel/StudioSlab · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
//
// Created by joao on 23/09/23.
//

#include "PythonUtils.h"

#include <iostream>
#include <string>
#include <stack>
#include <sstream>

namespace Slab::PythonUtils {

    Str PyTypeToString(EPyType type){
        switch (type) {
            case Integer:   return "Integer";
            case Float:     return "Float";
            case Bool:      return "Bool";
            case String:    return "String";
            default:        return "<unmapped>";
        }
    }

    bool BadPythonDictionary(const Str& pyDict) {
        std::stack<char> brackets;
        bool inQuotes = false;
        bool expectColon = false;
        bool expectComma = false;

        for (char c : pyDict) {
            if (c == ' ') continue;

            if (inQuotes) {
                if (c == '\'') {
                    inQuotes = false;
                    if (expectColon) expectColon = false;
                    else expectComma = true;
                }
                continue;
            }

            switch (c) {
                case '{':
                    if (expectColon || expectComma) return false;
                    brackets.push(c);
                    break;
                case '}':
                    if (brackets.empty() || brackets.top() != '{' || expectColon) return false;
                    brackets.pop();
                    break;
                case '\'':
                    inQuotes = true;
                    if (expectComma) expectComma = false;
                    break;
                case ':':
                    if (!expectColon || expectComma) return false;
                    expectColon = false;
                    break;
                case ',':
                    if (expectColon || !expectComma) return false;
                    expectComma = false;
                    expectColon = true;
                    break;
                default:
                    if (expectColon || expectComma) return false;
                    break;
            }
        }

        return brackets.empty() && !expectColon && !expectComma;
    }

    PyDict ParsePythonDict(const std::string& pyDict) {
        PyDict resultMap;
        Str key;
        StringValue value;
        bool isKey = true;

        std::stringstream ss(pyDict);
        char c;

        while (ss >> c) {
            if (c == '{' || c == '}' || c == ' ' || c == ',') {
                continue;
            } else if (c == ':') {
                isKey = false;
                continue;
            } else if (c == '\"' || c == '\'') {
                Str temp;
                std::getline(ss, temp, c); // find the matching (double-) quotation mark.

                if (isKey)
                    key = temp;
                else {
                    value = temp;
                    resultMap[key] = {value, EPyType::String};
                    isKey = true;
                }
                continue;
            } else {
                Str temp;
                std::getline(ss, temp, ',');
                value = c + temp;

                EPyType type;
                if (value.find('.') != std::string::npos)
                    type = EPyType::Float;
                else if(value=="True" || value=="False")
                    type = EPyType::Bool;
                else
                    type = EPyType::Integer;

                resultMap[key] = {value, type};
                isKey = true;
            }
        }

        return resultMap;
    }

    FPyDictException::FPyDictException(const std::string &msg) : Exception(msg) {

    }
}