Inter4ql  5.2
Checker.h
1 #ifndef __CHECKER_H__
2 #define __CHECKER_H__
3 
4 #include <vector>
5 #include <string>
6 #include <map>
7 #include <set>
8 
9 #include "Functions.h"
10 #include "Types.h"
11 
12 namespace Inter4ql {
13 
14  class VariableSpace;
15  class ModuleGeneric;
16  class ModuleLocal;
17  class ModuleGroup;
18  class ModuleBelief;
19  class Program;
20  class Value;
21  class Fact;
22  class Domain;
23  class Rule;
24  class Relation;
25  class ConstraintEntry;
29  class Checker {
30  public:
35  explicit Checker(std::vector<ModuleGeneric *> *_modules);
40  void set_modules(std::vector<ModuleGeneric *> *_modules);
45  void check(Program *p);
50  void check_query(Fact *r);
51 
56  void check_expression(Expression* expr);
57  private:
58  void check_cycles();
59  void check_module(ModuleLocal *m);
60  void check_module(ModuleGroup *m);
61  void check_module(ModuleBelief *m);
62  void check_module(ModuleAction *m);
63  void check_module(ModuleProblem *m);
64  void check_domain(ModuleLocal *m, Domain *_d);
65  void check_domain(ModuleGroup *m, Domain *_d);
66  void check_domain(ModuleBelief *m, Domain *_d);
67  void check_relation(ModuleGeneric *_m, Relation *_r);
68  void check_rule(ModuleGeneric *_m, Rule *_r, std::string msource,
69  std::map<std::string, variable_type::type> *vm_init = nullptr);
70  void check_fact(ModuleLocal *_m, Fact *_r);
71  void add_domain_facts(ModuleLocal *m);
72  void check_members(ModuleGroup *m, std::string name);
73  void check_composite(Expression* expr, std::string action_name, ModuleGeneric* m);
74 
75  void add_constraints_to_graph(
76  ModuleGeneric* current_module,
77  std::string type,
78  std::vector<Expression*>* constraints,
79  std::map<ModuleGeneric*,
80  std::set<ModuleGeneric*>*> *graph);
81  void check_parameters(
82  std::string msource,
83  std::string rname,
84  std::string mname,
85  std::vector<Domain*> *vd,
86  std::vector<Value*> *_vv,
87  std::map<std::string,variable_type::type> *map = 0,
88  std::set<std::string> *vars = 0);
89  void check_constraints(
90  std::string module,
91  std::string type,
92  std::vector<Expression*>* constraints,
93  std::vector<Domain*>* domains);
94  void check_bel(
95  std::string current_module,
96  Expression* bel_body,
97  std::set<std::string> *head_variables,
98  std::map<std::string, variable_type::type> *vm,
99  AsExpr* modules);
100  void check_bel_recursively(
101  std::string curent_module,
102  AsExpr* e,
103  Fact* term,
104  Expression* quantified_entry,
105  std::set<std::string> *head_variables,
106  std::map<std::string, variable_type::type> *vm);
107  void add_constraints_to_graph_recursive(
108  Expression* expr,
109  ModuleGeneric* current_module,
110  std::string type,
111  std::map<ModuleGeneric*, std::set<ModuleGeneric*>*> *graph);
112  void check_constraints_recursive(
113  Expression* expr,
114  std::map<std::string, variable_type::type> *vm,
115  std::string module,
116  std::string type,
117  std::vector<Domain*>* domains,
118  bool check_quantify = false);
119 
120  ModuleGeneric *get_pointer_to_module(std::string _module_name, bool outer = false);
121  std::vector<ModuleGeneric *> *modules;
122  /* this variable is set during checking */
123  Program *program;
124  };
125 }
126 
127 #endif
Checker class - class that validates 4QL programs.
Definition: Checker.h:29
class that implements a fact
Definition: Fact.h:14
Implementation of ModuleAction for modules with reasoning.
Definition: ModuleAction.h:21
void set_modules(std::vector< ModuleGeneric *> *_modules)
function to set the modules pointer
Definition: Checker.cc:30
Definition: Expression.h:10
void check(Program *p)
function that validates 4QL program, throws exception on failure
Definition: Checker.cc:34
Implementation of ModuleAction for modules with reasoning.
Definition: ModuleProblem.h:161
void check_expression(Expression *expr)
function that validates expression
Definition: Checker.cc:1001
Definition: Application.cc:37
Definition: Functions.h:17
Domain class - class that points to a data type.
Definition: Domain.h:12
Generic class of module (only virtual methods)
Definition: ModuleGeneric.h:21
Implementation of ModuleGeneric for modules with reasoning.
Definition: ModuleLocal.h:24
Implementation of ModuleGeneric for modules with reasoning.
Definition: ModuleGroup.h:20
class that handles rules in ModuleLocal
Definition: Rule.h:14
Checker(std::vector< ModuleGeneric *> *_modules)
constructor
Definition: Checker.cc:25
void check_query(Fact *r)
function that validates query
Definition: Checker.cc:972
Implementation of ModuleGeneric for modules with reasoning.
Definition: ModuleBelief.h:22
class that handles 4QL programs
Definition: Program.h:13
class that handles relation instance inside modules
Definition: Relation.h:13