MTMFinal/Command.h at master · stavgn/MTMFinal · 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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

#ifndef GCALC_COMMAND_H
#define GCALC_COMMAND_H

#include <map>
#include <vector>
#include <memory>
#include <string>
#include "./Graph.h"

using std::shared_ptr;

namespace gcalc

{
    struct IContextParams
    {
        std::string graphName = "";
        std::string temp_graphName = "";
        std::string graphNameToPrint = "";
    };

    class Command
    {
    public:
        Command();
        ~Command() = default;
        void virtual exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params);
    };

    class CreateAndAssignVertexCommand : public Command
    {
        std::string vertexName;

    public:
        CreateAndAssignVertexCommand(std::string vertexName);
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class CreateAndAssignEdgeCommand : public Command
    {
        std::string v1_name;
        std::string v2_name;

    public:
        CreateAndAssignEdgeCommand(std::string v1_name, std::string v2_name);
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class LeftOpperandAssignmentCommand : public Command
    {
    public:
        std::string graphName;
        LeftOpperandAssignmentCommand(std::string graphName);
        ~LeftOpperandAssignmentCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class FindGraphCommand : public Command
    {
        std::string graphName;
        std::string attribute;

    public:
        FindGraphCommand(std::string graphName, std::string attribute);
        ~FindGraphCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class EvalCommand;

    class OperationCommand : public Command
    {
        shared_ptr<EvalCommand> exp1;
        shared_ptr<EvalCommand> exp2;
        std::string op;

    public:
        OperationCommand(EvalCommand ex1, EvalCommand ex2, std::string op);
        ~OperationCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class LoadCommand : public Command
    {
        std::string filename;

    public:
        LoadCommand(std::string filename);
        ~LoadCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class EvalCommand : public Command
    {
    public:
        std::vector<shared_ptr<CreateAndAssignVertexCommand>> VertexCommands;
        std::vector<shared_ptr<CreateAndAssignEdgeCommand>> EdgeCommands;
        std::vector<shared_ptr<FindGraphCommand>> FindCommands;
        std::vector<shared_ptr<EvalCommand>> SubEvalCommands;
        std::vector<shared_ptr<OperationCommand>> OperationCommands;
        std::vector<shared_ptr<LoadCommand>> LoadCommands;

        EvalCommand();
        ~EvalCommand() = default;
        void addCommand(CreateAndAssignVertexCommand command);
        void addCommand(CreateAndAssignEdgeCommand command);
        void addCommand(FindGraphCommand command);
        void addCommand(EvalCommand command);
        void addCommand(OperationCommand command);
        void addCommand(LoadCommand command);

        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class AssignmentCommand : public Command
    {
        LeftOpperandAssignmentCommand c1;
        EvalCommand c2;

    public:
        AssignmentCommand(LeftOpperandAssignmentCommand c1, EvalCommand c2);
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class PrintCommand : public Command
    {
        EvalCommand evalCommand;

    public:
        PrintCommand(EvalCommand evalCommand);
        ~PrintCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class WhoCommand : public Command
    {
    public:
        WhoCommand();
        ~WhoCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class ResetCommand : public Command
    {
    public:
        ResetCommand();
        ~ResetCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class DeleteCommand : public Command
    {
        std::string graphName;

    public:
        DeleteCommand(std::string graphName);
        ~DeleteCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

    class SaveCommand : public Command
    {
        std::string filename;
        EvalCommand evalCommand;

    public:
        SaveCommand(std::string filename, EvalCommand evalCommand);
        ~SaveCommand() = default;
        void exec(std::map<std::string, shared_ptr<Graph>> &context, IContextParams &params) override;
    };

} // namespace gcalc

#endif