summary refs log tree commit diff stats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--CMakeLists.txt2
-rw-r--r--generator/frame.cpp69
-rw-r--r--generator/frame.h20
-rw-r--r--generator/generator.cpp39
-rw-r--r--generator/generator.h3
-rw-r--r--generator/group.cpp166
-rw-r--r--generator/group.h30
-rw-r--r--generator/part.cpp48
-rw-r--r--generator/part.h30
-rw-r--r--generator/role.h (renamed from lib/role.h)0
-rw-r--r--generator/schema.sql33
-rw-r--r--generator/word.h1
-rw-r--r--lib/database.cpp60
-rw-r--r--lib/database.h20
-rw-r--r--lib/enums.h14
-rw-r--r--lib/field.cpp20
-rw-r--r--lib/field.h78
-rw-r--r--lib/filter.cpp35
-rw-r--r--lib/form.cpp16
-rw-r--r--lib/form.h31
-rw-r--r--lib/frame.cpp95
-rw-r--r--lib/frame.h21
-rw-r--r--lib/group.cpp61
-rw-r--r--lib/group.h91
-rw-r--r--lib/lemma.cpp15
-rw-r--r--lib/lemma.h27
-rw-r--r--lib/order.h69
-rw-r--r--lib/part.cpp128
-rw-r--r--lib/part.h64
-rw-r--r--lib/query.h11
-rw-r--r--lib/statement.cpp164
-rw-r--r--lib/statement.h9
-rw-r--r--lib/verbly.h5
-rw-r--r--lib/word.cpp36
-rw-r--r--lib/word.h23
35 files changed, 885 insertions, 649 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 5c15e79..32c73c1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt
@@ -7,7 +7,7 @@ pkg_check_modules(sqlite3 sqlite3>=3.8.3 REQUIRED)
7set(CMAKE_BUILD_TYPE Debug) 7set(CMAKE_BUILD_TYPE Debug)
8 8
9include_directories(vendor/json) 9include_directories(vendor/json)
10add_library(verbly lib/filter.cpp lib/field.cpp lib/notion.cpp lib/word.cpp lib/group.cpp lib/frame.cpp lib/lemma.cpp lib/form.cpp lib/pronunciation.cpp lib/statement.cpp lib/binding.cpp lib/database.cpp lib/token.cpp lib/selrestr.cpp lib/part.cpp) 10add_library(verbly lib/filter.cpp lib/field.cpp lib/notion.cpp lib/word.cpp lib/frame.cpp lib/part.cpp lib/lemma.cpp lib/form.cpp lib/pronunciation.cpp lib/statement.cpp lib/binding.cpp lib/database.cpp lib/token.cpp lib/selrestr.cpp lib/part.cpp)
11set_property(TARGET verbly PROPERTY CXX_STANDARD 11) 11set_property(TARGET verbly PROPERTY CXX_STANDARD 11)
12set_property(TARGET verbly PROPERTY CXX_STANDARD_REQUIRED ON) 12set_property(TARGET verbly PROPERTY CXX_STANDARD_REQUIRED ON)
13target_link_libraries(verbly ${sqlite3_LIBRARIES}) 13target_link_libraries(verbly ${sqlite3_LIBRARIES})
diff --git a/generator/frame.cpp b/generator/frame.cpp index f75e3ba..4e4ac5f 100644 --- a/generator/frame.cpp +++ b/generator/frame.cpp
@@ -11,72 +11,21 @@ namespace verbly {
11 { 11 {
12 } 12 }
13 13
14 void frame::push_back(part fp) 14 frame frame::duplicate(const frame& other)
15 {
16 parts_.push_back(std::move(fp));
17 }
18
19 database& operator<<(database& db, const frame& arg)
20 { 15 {
21 std::list<field> fields; 16 frame result;
22 fields.emplace_back("frame_id", arg.getId());
23 17
24 nlohmann::json jsonParts; 18 for (const part& p : other.parts_)
25 for (const part& p : arg)
26 { 19 {
27 nlohmann::json jsonPart; 20 result.push_back(part::duplicate(p));
28 jsonPart["type"] = static_cast<int>(p.getType());
29
30 switch (p.getType())
31 {
32 case part::type::noun_phrase:
33 {
34 jsonPart["role"] = p.getNounRole();
35 jsonPart["selrestrs"] = p.getNounSelrestrs().toJson();
36 jsonPart["synrestrs"] = p.getNounSynrestrs();
37
38 break;
39 }
40
41 case part::type::preposition:
42 {
43 jsonPart["choices"] = p.getPrepositionChoices();
44 jsonPart["literal"] = p.isPrepositionLiteral();
45
46 break;
47 }
48
49 case part::type::literal:
50 {
51 jsonPart["value"] = p.getLiteralValue();
52
53 break;
54 }
55
56 case part::type::verb:
57 case part::type::adjective:
58 case part::type::adverb:
59 {
60 break;
61 }
62
63 case part::type::invalid:
64 {
65 // Invalid parts should not be serialized.
66 assert(false);
67
68 break;
69 }
70 }
71
72 jsonParts.push_back(std::move(jsonPart));
73 } 21 }
74 22
75 fields.emplace_back("data", jsonParts.dump()); 23 return result;
76 24 }
77 db.insertIntoTable("frames", std::move(fields));
78 25
79 return db; 26 void frame::push_back(part fp)
27 {
28 parts_.push_back(std::move(fp));
80 } 29 }
81 30
82 }; 31 };
diff --git a/generator/frame.h b/generator/frame.h index 764564d..ba266f0 100644 --- a/generator/frame.h +++ b/generator/frame.h
@@ -19,6 +19,10 @@ namespace verbly {
19 // Constructor 19 // Constructor
20 20
21 frame(); 21 frame();
22
23 // Duplication
24
25 static frame duplicate(const frame& other);
22 26
23 // Mutators 27 // Mutators
24 28
@@ -30,15 +34,15 @@ namespace verbly {
30 { 34 {
31 return id_; 35 return id_;
32 } 36 }
33 37
34 const_iterator begin() const 38 int getLength() const
35 { 39 {
36 return std::begin(parts_); 40 return parts_.size();
37 } 41 }
38 42
39 const_iterator end() const 43 const part& operator[](int index) const
40 { 44 {
41 return std::end(parts_); 45 return parts_.at(index);
42 } 46 }
43 47
44 private: 48 private:
@@ -47,12 +51,10 @@ namespace verbly {
47 51
48 const int id_; 52 const int id_;
49 53
50 std::list<part> parts_; 54 std::vector<part> parts_;
51 55
52 }; 56 };
53 57
54 database& operator<<(database& db, const frame& arg);
55
56 }; 58 };
57}; 59};
58 60
diff --git a/generator/generator.cpp b/generator/generator.cpp index 610a602..4cc9f64 100644 --- a/generator/generator.cpp +++ b/generator/generator.cpp
@@ -8,7 +8,7 @@
8#include "../lib/enums.h" 8#include "../lib/enums.h"
9#include "progress.h" 9#include "progress.h"
10#include "../lib/selrestr.h" 10#include "../lib/selrestr.h"
11#include "../lib/role.h" 11#include "role.h"
12#include "part.h" 12#include "part.h"
13#include "field.h" 13#include "field.h"
14#include "../lib/util.h" 14#include "../lib/util.h"
@@ -640,7 +640,7 @@ namespace verbly {
640 } 640 }
641 641
642 { 642 {
643 progress ppgs("Writing verb groups...", groups_.size()); 643 progress ppgs("Writing verb frames...", groups_.size());
644 644
645 for (group& g : groups_) 645 for (group& g : groups_)
646 { 646 {
@@ -649,17 +649,6 @@ namespace verbly {
649 ppgs.update(); 649 ppgs.update();
650 } 650 }
651 } 651 }
652
653 {
654 progress ppgs("Writing verb frames...", frames_.size());
655
656 for (frame& f : frames_)
657 {
658 db_ << f;
659
660 ppgs.update();
661 }
662 }
663 } 652 }
664 653
665 void generator::readWordNetAntonymy() 654 void generator::readWordNetAntonymy()
@@ -1212,9 +1201,15 @@ namespace verbly {
1212 return w; 1201 return w;
1213 } 1202 }
1214 1203
1215 group& generator::createGroup(xmlNodePtr top) 1204 void generator::createGroup(xmlNodePtr top, const group* parent)
1216 { 1205 {
1217 groups_.emplace_back(); 1206 if (parent != nullptr)
1207 {
1208 groups_.emplace_back(*parent);
1209 } else {
1210 groups_.emplace_back();
1211 }
1212
1218 group& grp = groups_.back(); 1213 group& grp = groups_.back();
1219 1214
1220 xmlChar* key; 1215 xmlChar* key;
@@ -1229,8 +1224,11 @@ namespace verbly {
1229 { 1224 {
1230 try 1225 try
1231 { 1226 {
1232 group& subgrp = createGroup(subclass); 1227 // Parsing a subgroup starts by making a copy of everything in
1233 subgrp.setParent(grp); 1228 // the parent. This is okay to do at this point because in the
1229 // VerbNet data, subgroups are always defined after everything
1230 // else.
1231 createGroup(subclass, &grp);
1234 } catch (const std::exception& e) 1232 } catch (const std::exception& e)
1235 { 1233 {
1236 key = xmlGetProp(subclass, reinterpret_cast<const xmlChar*>("ID")); 1234 key = xmlGetProp(subclass, reinterpret_cast<const xmlChar*>("ID"));
@@ -1323,8 +1321,7 @@ namespace verbly {
1323 { 1321 {
1324 if (!xmlStrcmp(frametopnode->name, reinterpret_cast<const xmlChar*>("FRAME"))) 1322 if (!xmlStrcmp(frametopnode->name, reinterpret_cast<const xmlChar*>("FRAME")))
1325 { 1323 {
1326 frames_.emplace_back(); 1324 frame fr;
1327 frame& fr = frames_.back();
1328 1325
1329 for (xmlNodePtr framenode = frametopnode->xmlChildrenNode; framenode != nullptr; framenode = framenode->next) 1326 for (xmlNodePtr framenode = frametopnode->xmlChildrenNode; framenode != nullptr; framenode = framenode->next)
1330 { 1327 {
@@ -1428,15 +1425,13 @@ namespace verbly {
1428 } 1425 }
1429 } 1426 }
1430 1427
1431 grp.addFrame(fr); 1428 grp.addFrame(std::move(fr));
1432 } 1429 }
1433 } 1430 }
1434 } 1431 }
1435 } 1432 }
1436 } 1433 }
1437 } 1434 }
1438
1439 return grp;
1440 } 1435 }
1441 1436
1442 selrestr generator::parseSelrestr(xmlNodePtr top) 1437 selrestr generator::parseSelrestr(xmlNodePtr top)
diff --git a/generator/generator.h b/generator/generator.h index 8352693..bc9b3c7 100644 --- a/generator/generator.h +++ b/generator/generator.h
@@ -105,7 +105,7 @@ namespace verbly {
105 105
106 template <typename... Args> word& createWord(Args&&... args); 106 template <typename... Args> word& createWord(Args&&... args);
107 107
108 group& createGroup(xmlNodePtr top); 108 void createGroup(xmlNodePtr top, const group* parent = nullptr);
109 109
110 selrestr parseSelrestr(xmlNodePtr top); 110 selrestr parseSelrestr(xmlNodePtr top);
111 111
@@ -128,7 +128,6 @@ namespace verbly {
128 std::list<lemma> lemmas_; 128 std::list<lemma> lemmas_;
129 std::list<form> forms_; 129 std::list<form> forms_;
130 std::list<pronunciation> pronunciations_; 130 std::list<pronunciation> pronunciations_;
131 std::list<frame> frames_;
132 std::list<group> groups_; 131 std::list<group> groups_;
133 132
134 // Indexes 133 // Indexes
diff --git a/generator/group.cpp b/generator/group.cpp index cebe2b9..aa28d42 100644 --- a/generator/group.cpp +++ b/generator/group.cpp
@@ -15,12 +15,15 @@ namespace verbly {
15 { 15 {
16 } 16 }
17 17
18 void group::setParent(const group& parent) 18 group::group(const group& parent) :
19 id_(nextId_++),
20 roles_(parent.roles_),
21 roleNames_(parent.roleNames_)
19 { 22 {
20 // Adding a group to itself is nonsensical. 23 for (const frame& f : parent.frames_)
21 assert(&parent != this); 24 {
22 25 frames_.push_back(frame::duplicate(f));
23 parent_ = &parent; 26 }
24 } 27 }
25 28
26 void group::addRole(role r) 29 void group::addRole(role r)
@@ -30,87 +33,114 @@ namespace verbly {
30 roleNames_.insert(std::move(name)); 33 roleNames_.insert(std::move(name));
31 } 34 }
32 35
33 void group::addFrame(const frame& f) 36 void group::addFrame(frame f)
34 { 37 {
35 frames_.insert(&f); 38 frames_.push_back(std::move(f));
36 } 39 }
37 40
38 std::set<std::string> group::getRoles() const 41 bool group::hasRole(std::string name) const
39 { 42 {
40 std::set<std::string> fullRoles = roleNames_; 43 // Rarely, a noun phrase part may use a role that is not defined in the
41 44 // group. See confess-37.10 "NP V NP ADJ".
42 if (hasParent()) 45 return (roles_.count(name) == 1);
43 {
44 for (std::string name : getParent().getRoles())
45 {
46 fullRoles.insert(name);
47 }
48 }
49
50 return fullRoles;
51 } 46 }
52 47
53 const role& group::getRole(std::string name) const 48 const role& group::getRole(std::string name) const
54 { 49 {
55 if (roles_.count(name)) 50 return roles_.at(name);
56 {
57 return roles_.at(name);
58 } else if (hasParent())
59 {
60 return getParent().getRole(name);
61 } else {
62 throw std::invalid_argument("Specified role not found in verb group");
63 }
64 }
65
66 std::set<const frame*> group::getFrames() const
67 {
68 std::set<const frame*> fullFrames = frames_;
69
70 if (hasParent())
71 {
72 for (const frame* f : getParent().getFrames())
73 {
74 fullFrames.insert(f);
75 }
76 }
77
78 return fullFrames;
79 } 51 }
80 52
81 database& operator<<(database& db, const group& arg) 53 database& operator<<(database& db, const group& arg)
82 { 54 {
83 // Serialize the group first 55 // Serialize each frame
56 for (const frame& f : arg.getFrames())
84 { 57 {
85 std::list<field> fields; 58 // First, serialize the group/frame relationship
86 fields.emplace_back("group_id", arg.getId());
87
88 nlohmann::json jsonRoles;
89 for (std::string name : arg.getRoles())
90 { 59 {
91 const role& r = arg.getRole(name); 60 std::list<field> fields;
92 61
93 nlohmann::json jsonRole; 62 fields.emplace_back("frame_id", f.getId());
94 jsonRole["type"] = name; 63 fields.emplace_back("group_id", arg.getId());
95 jsonRole["selrestrs"] = r.getSelrestrs().toJson(); 64 fields.emplace_back("length", f.getLength());
96 65
97 jsonRoles.emplace_back(std::move(jsonRole)); 66 db.insertIntoTable("frames", std::move(fields));
98 } 67 }
99 68
100 fields.emplace_back("data", jsonRoles.dump()); 69 // Then, serialize the frame parts in the context of the group
101 70 for (int partIndex = 0; partIndex < f.getLength(); partIndex++)
102 db.insertIntoTable("groups", std::move(fields)); 71 {
103 } 72 const part& p = f[partIndex];
104 73
105 // Then, serialize the group/frame relationship 74 std::list<field> fields;
106 for (const frame* f : arg.getFrames()) 75 fields.emplace_back("part_id", p.getId());
107 { 76 fields.emplace_back("frame_id", f.getId());
108 std::list<field> fields; 77 fields.emplace_back("part_index", partIndex);
109 78 fields.emplace_back("type", static_cast<int>(p.getType()));
110 fields.emplace_back("group_id", arg.getId()); 79
111 fields.emplace_back("frame_id", f->getId()); 80 switch (p.getType())
112 81 {
113 db.insertIntoTable("groups_frames", std::move(fields)); 82 case part::type::noun_phrase:
83 {
84 fields.emplace_back("role", p.getNounRole());
85
86 selrestr partSelrestr;
87 if (p.getNounSelrestrs().getType() != selrestr::type::empty)
88 {
89 partSelrestr = p.getNounSelrestrs();
90 } else if (arg.hasRole(p.getNounRole()))
91 {
92 partSelrestr = arg.getRole(p.getNounRole()).getSelrestrs();
93 }
94
95 fields.emplace_back("selrestrs", partSelrestr.toJson().dump());
96
97 // Short interlude to serialize the synrestrs
98 for (const std::string& s : p.getNounSynrestrs())
99 {
100 std::list<field> synrestrFields;
101
102 synrestrFields.emplace_back("part_id", p.getId());
103 synrestrFields.emplace_back("synrestr", s);
104
105 db.insertIntoTable("synrestrs", std::move(synrestrFields));
106 }
107
108 break;
109 }
110
111 case part::type::preposition:
112 {
113 fields.emplace_back("prepositions", nlohmann::json(p.getPrepositionChoices()).dump());
114 fields.emplace_back("preposition_literality", p.isPrepositionLiteral() ? 1 : 0);
115
116 break;
117 }
118
119 case part::type::literal:
120 {
121 fields.emplace_back("literal_value", p.getLiteralValue());
122
123 break;
124 }
125
126 case part::type::verb:
127 case part::type::adjective:
128 case part::type::adverb:
129 {
130 break;
131 }
132
133 case part::type::invalid:
134 {
135 // Invalid parts should not be serialized.
136 assert(false);
137
138 break;
139 }
140 }
141
142 db.insertIntoTable("parts", std::move(fields));
143 }
114 } 144 }
115 145
116 return db; 146 return db;
diff --git a/generator/group.h b/generator/group.h index 83f40c2..5486fbe 100644 --- a/generator/group.h +++ b/generator/group.h
@@ -5,7 +5,7 @@
5#include <set> 5#include <set>
6#include <string> 6#include <string>
7#include <cassert> 7#include <cassert>
8#include "../lib/role.h" 8#include "role.h"
9 9
10namespace verbly { 10namespace verbly {
11 namespace generator { 11 namespace generator {
@@ -20,13 +20,13 @@ namespace verbly {
20 20
21 group(); 21 group();
22 22
23 // Mutators 23 explicit group(const group& parent);
24 24
25 void setParent(const group& parent); 25 // Mutators
26 26
27 void addRole(role r); 27 void addRole(role r);
28 28
29 void addFrame(const frame& f); 29 void addFrame(frame f);
30 30
31 // Accessors 31 // Accessors
32 32
@@ -35,24 +35,19 @@ namespace verbly {
35 return id_; 35 return id_;
36 } 36 }
37 37
38 bool hasParent() const 38 const std::set<std::string>& getRoles() const
39 {
40 return (parent_ != nullptr);
41 }
42
43 const group& getParent() const
44 { 39 {
45 // Calling code should always call hasParent first 40 return roleNames_;
46 assert(parent_ != nullptr);
47
48 return *parent_;
49 } 41 }
50 42
51 std::set<std::string> getRoles() const; 43 bool hasRole(std::string name) const;
52 44
53 const role& getRole(std::string name) const; 45 const role& getRole(std::string name) const;
54 46
55 std::set<const frame*> getFrames() const; 47 const std::list<frame>& getFrames() const
48 {
49 return frames_;
50 }
56 51
57 private: 52 private:
58 53
@@ -60,9 +55,8 @@ namespace verbly {
60 55
61 const int id_; 56 const int id_;
62 57
63 const group* parent_ = nullptr;
64 std::map<std::string, role> roles_; 58 std::map<std::string, role> roles_;
65 std::set<const frame*> frames_; 59 std::list<frame> frames_;
66 60
67 // Caches 61 // Caches
68 62
diff --git a/generator/part.cpp b/generator/part.cpp index 8a75ed4..07618a8 100644 --- a/generator/part.cpp +++ b/generator/part.cpp
@@ -4,6 +4,8 @@
4namespace verbly { 4namespace verbly {
5 namespace generator { 5 namespace generator {
6 6
7 int part::nextId_ = 0;
8
7 part part::createNounPhrase(std::string role, selrestr selrestrs, std::set<std::string> synrestrs) 9 part part::createNounPhrase(std::string role, selrestr selrestrs, std::set<std::string> synrestrs)
8 { 10 {
9 part p(type::noun_phrase); 11 part p(type::noun_phrase);
@@ -49,9 +51,52 @@ namespace verbly {
49 return p; 51 return p;
50 } 52 }
51 53
54 part part::duplicate(const part& other)
55 {
56 part result(other.type_);
57
58 switch (result.type_)
59 {
60 case type::noun_phrase:
61 {
62 new(&result.noun_phrase_.role) std::string(other.noun_phrase_.role);
63 new(&result.noun_phrase_.selrestrs) selrestr(other.noun_phrase_.selrestrs);
64 new(&result.noun_phrase_.synrestrs) std::set<std::string>(other.noun_phrase_.synrestrs);
65
66 break;
67 }
68
69 case type::preposition:
70 {
71 new(&result.preposition_.choices) std::set<std::string>(other.preposition_.choices);
72 result.preposition_.literal = other.preposition_.literal;
73
74 break;
75 }
76
77 case type::literal:
78 {
79 new(&result.literal_) std::string(other.literal_);
80
81 break;
82 }
83
84 case type::verb:
85 case type::adjective:
86 case type::adverb:
87 case type::invalid:
88 {
89 break;
90 }
91 }
92
93 return result;
94 }
95
52 part::part(const part& other) 96 part::part(const part& other)
53 { 97 {
54 type_ = other.type_; 98 type_ = other.type_;
99 id_ = other.id_;
55 100
56 switch (type_) 101 switch (type_)
57 { 102 {
@@ -106,6 +151,7 @@ namespace verbly {
106 using type = part::type; 151 using type = part::type;
107 152
108 type tempType = first.type_; 153 type tempType = first.type_;
154 int tempId = first.id_;
109 std::string tempRole; 155 std::string tempRole;
110 selrestr tempSelrestrs; 156 selrestr tempSelrestrs;
111 std::set<std::string> tempSynrestrs; 157 std::set<std::string> tempSynrestrs;
@@ -151,6 +197,7 @@ namespace verbly {
151 first.~part(); 197 first.~part();
152 198
153 first.type_ = second.type_; 199 first.type_ = second.type_;
200 first.id_ = second.id_;
154 201
155 switch (first.type_) 202 switch (first.type_)
156 { 203 {
@@ -190,6 +237,7 @@ namespace verbly {
190 second.~part(); 237 second.~part();
191 238
192 second.type_ = tempType; 239 second.type_ = tempType;
240 second.id_ = tempId;
193 241
194 switch (second.type_) 242 switch (second.type_)
195 { 243 {
diff --git a/generator/part.h b/generator/part.h index b010f62..39ba1e7 100644 --- a/generator/part.h +++ b/generator/part.h
@@ -4,21 +4,16 @@
4#include <string> 4#include <string>
5#include <set> 5#include <set>
6#include "../lib/selrestr.h" 6#include "../lib/selrestr.h"
7#include "../lib/enums.h"
7 8
8namespace verbly { 9namespace verbly {
10
9 namespace generator { 11 namespace generator {
10 12
11 class part { 13 class part {
12 public: 14 public:
13 enum class type { 15
14 invalid = -1, 16 using type = part_type;
15 noun_phrase = 0,
16 verb = 1,
17 preposition = 2,
18 adjective = 3,
19 adverb = 4,
20 literal = 5
21 };
22 17
23 // Static factories 18 // Static factories
24 19
@@ -34,6 +29,10 @@ namespace verbly {
34 29
35 static part createLiteral(std::string value); 30 static part createLiteral(std::string value);
36 31
32 // Duplication
33
34 static part duplicate(const part& other);
35
37 // Copy and move constructors 36 // Copy and move constructors
38 37
39 part(const part& other); 38 part(const part& other);
@@ -54,6 +53,11 @@ namespace verbly {
54 53
55 // General accessors 54 // General accessors
56 55
56 int getId() const
57 {
58 return id_;
59 }
60
57 type getType() const 61 type getType() const
58 { 62 {
59 return type_; 63 return type_;
@@ -79,13 +83,19 @@ namespace verbly {
79 83
80 private: 84 private:
81 85
86 static int nextId_;
87
88 int id_;
89
82 // Private constructors 90 // Private constructors
83 91
84 part() 92 part()
85 { 93 {
86 } 94 }
87 95
88 part(type t) : type_(t) 96 part(type t) :
97 id_(nextId_++),
98 type_(t)
89 { 99 {
90 } 100 }
91 101
diff --git a/lib/role.h b/generator/role.h index 4884ef3..4884ef3 100644 --- a/lib/role.h +++ b/generator/role.h
diff --git a/generator/schema.sql b/generator/schema.sql index c3e54d8..33ebc28 100644 --- a/generator/schema.sql +++ b/generator/schema.sql
@@ -186,19 +186,32 @@ CREATE TABLE `forms_pronunciations` (
186CREATE INDEX `pronunciation_of` ON `forms_pronunciations`(`form_id`); 186CREATE INDEX `pronunciation_of` ON `forms_pronunciations`(`form_id`);
187CREATE INDEX `spelling_of` ON `forms_pronunciations`(`pronunciation_id`); 187CREATE INDEX `spelling_of` ON `forms_pronunciations`(`pronunciation_id`);
188 188
189CREATE TABLE `groups` ( 189CREATE TABLE `frames` (
190 `group_id` INTEGER PRIMARY KEY, 190 `frame_id` INTEGER NOT NULL,
191 `data` BLOB NOT NULL 191 `group_id` INTEGER NOT NULL,
192 'length' INTEGER NOT NULL
192); 193);
193 194
194CREATE TABLE `frames` ( 195CREATE INDEX `frames_in` ON `frames`(`group_id`);
195 `frame_id` INTEGER PRIMARY KEY, 196
196 `data` BLOB NOT NULL 197CREATE TABLE `parts` (
198 `part_id` INTEGER PRIMARY KEY,
199 `frame_id` INTEGER NOT NULL,
200 `part_index` INTEGER NOT NULL,
201 `type` INTEGER NOT NULL,
202 `role` VARCHAR(16),
203 `selrestrs` BLOB,
204 `prepositions` BLOB,
205 `preposition_literality` SMALLINT,
206 `literal_value` VARCHAR(64)
197); 207);
198 208
199CREATE TABLE `groups_frames` ( 209CREATE INDEX `parts_of` ON `parts`(`frame_id`);
200 `group_id` INTEGER NOT NULL, 210CREATE UNIQUE INDEX `part_by_frame_index` ON `parts`(`frame_id`, `part_index`);
201 `frame_id` INTEGER NOT NULL 211
212CREATE TABLE `synrestrs` (
213 `part_id` INTEGER NOT NULL,
214 `synrestr` VARCHAR(32) NOT NULL
202); 215);
203 216
204CREATE INDEX `frames_in` ON `groups_frames`(`group_id`); 217CREATE INDEX `synrestrs_for` ON `synrestrs`(`part_id`);
diff --git a/generator/word.h b/generator/word.h index a994ec3..c6d7b20 100644 --- a/generator/word.h +++ b/generator/word.h
@@ -5,6 +5,7 @@
5#include "../lib/enums.h" 5#include "../lib/enums.h"
6 6
7namespace verbly { 7namespace verbly {
8
8 namespace generator { 9 namespace generator {
9 10
10 class notion; 11 class notion;
diff --git a/lib/database.cpp b/lib/database.cpp index fb00ef3..563ec31 100644 --- a/lib/database.cpp +++ b/lib/database.cpp
@@ -41,39 +41,71 @@ namespace verbly {
41 sqlite3_close_v2(ppdb_); 41 sqlite3_close_v2(ppdb_);
42 } 42 }
43 43
44 query<notion> database::notions(filter where, bool random, int limit) const 44 query<notion> database::notions(filter where, order sortOrder, int limit) const
45 { 45 {
46 return query<notion>(*this, ppdb_, std::move(where), random, limit); 46 return query<notion>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
47 } 47 }
48 48
49 query<word> database::words(filter where, bool random, int limit) const 49 query<word> database::words(filter where, order sortOrder, int limit) const
50 { 50 {
51 return query<word>(*this, ppdb_, std::move(where), random, limit); 51 return query<word>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
52 } 52 }
53 53
54 query<group> database::groups(filter where, bool random, int limit) const 54 query<frame> database::frames(filter where, order sortOrder, int limit) const
55 { 55 {
56 return query<group>(*this, ppdb_, std::move(where), random, limit); 56 return query<frame>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
57 } 57 }
58 58
59 query<frame> database::frames(filter where, bool random, int limit) const 59 query<part> database::parts(filter where, order sortOrder, int limit) const
60 { 60 {
61 return query<frame>(*this, ppdb_, std::move(where), random, limit); 61 return query<part>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
62 } 62 }
63 63
64 query<lemma> database::lemmas(filter where, bool random, int limit) const 64 query<lemma> database::lemmas(filter where, order sortOrder, int limit) const
65 { 65 {
66 return query<lemma>(*this, ppdb_, std::move(where), random, limit); 66 return query<lemma>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
67 } 67 }
68 68
69 query<form> database::forms(filter where, bool random, int limit) const 69 query<form> database::forms(filter where, order sortOrder, int limit) const
70 { 70 {
71 return query<form>(*this, ppdb_, std::move(where), random, limit); 71 return query<form>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
72 } 72 }
73 73
74 query<pronunciation> database::pronunciations(filter where, bool random, int limit) const 74 query<pronunciation> database::pronunciations(filter where, order sortOrder, int limit) const
75 { 75 {
76 return query<pronunciation>(*this, ppdb_, std::move(where), random, limit); 76 return query<pronunciation>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
77 }
78
79 std::set<std::string> database::synrestrs(int partId) const
80 {
81 std::string queryString = "SELECT synrestr FROM synrestrs WHERE part_id = ?";
82
83 sqlite3_stmt* ppstmt;
84 if (sqlite3_prepare_v2(ppdb_, queryString.c_str(), queryString.length(), &ppstmt, NULL) != SQLITE_OK)
85 {
86 std::string errorMsg = sqlite3_errmsg(ppdb_);
87 sqlite3_finalize(ppstmt);
88
89 throw database_error("Error preparing query", errorMsg);
90 }
91
92 if (sqlite3_bind_int(ppstmt, 1, partId) != SQLITE_OK)
93 {
94 std::string errorMsg = sqlite3_errmsg(ppdb_);
95 sqlite3_finalize(ppstmt);
96
97 throw database_error("Error binding value to query", errorMsg);
98 }
99
100 std::set<std::string> result;
101 while (sqlite3_step(ppstmt) == SQLITE_ROW)
102 {
103 result.insert(reinterpret_cast<const char*>(sqlite3_column_blob(ppstmt, 0)));
104 }
105
106 sqlite3_finalize(ppstmt);
107
108 return result;
77 } 109 }
78 110
79}; 111};
diff --git a/lib/database.h b/lib/database.h index ef50739..0b10eba 100644 --- a/lib/database.h +++ b/lib/database.h
@@ -4,13 +4,15 @@
4#include <string> 4#include <string>
5#include <exception> 5#include <exception>
6#include <list> 6#include <list>
7#include <set>
7#include "notion.h" 8#include "notion.h"
8#include "word.h" 9#include "word.h"
9#include "group.h"
10#include "frame.h" 10#include "frame.h"
11#include "part.h"
11#include "lemma.h" 12#include "lemma.h"
12#include "form.h" 13#include "form.h"
13#include "pronunciation.h" 14#include "pronunciation.h"
15#include "order.h"
14 16
15struct sqlite3; 17struct sqlite3;
16 18
@@ -46,19 +48,21 @@ namespace verbly {
46 48
47 // Queries 49 // Queries
48 50
49 query<notion> notions(filter where, bool random = true, int limit = 1) const; 51 query<notion> notions(filter where, order sortOrder = {}, int limit = 1) const;
50 52
51 query<word> words(filter where, bool random = true, int limit = 1) const; 53 query<word> words(filter where, order sortOrder = {}, int limit = 1) const;
52 54
53 query<group> groups(filter where, bool random = true, int limit = 1) const; 55 query<frame> frames(filter where, order sortOrder = {}, int limit = 1) const;
54 56
55 query<frame> frames(filter where, bool random = true, int limit = 1) const; 57 query<part> parts(filter where, order sortOrder = {}, int limit = 1) const;
56 58
57 query<lemma> lemmas(filter where, bool random = true, int limit = 1) const; 59 query<lemma> lemmas(filter where, order sortOrder = {}, int limit = 1) const;
58 60
59 query<form> forms(filter where, bool random = true, int limit = 1) const; 61 query<form> forms(filter where, order sortOrder = {}, int limit = 1) const;
60 62
61 query<pronunciation> pronunciations(filter where, bool random = true, int limit = 1) const; 63 query<pronunciation> pronunciations(filter where, order sortOrder = {}, int limit = 1) const;
64
65 std::set<std::string> synrestrs(int partId) const;
62 66
63 private: 67 private:
64 68
diff --git a/lib/enums.h b/lib/enums.h index e634959..2646fa4 100644 --- a/lib/enums.h +++ b/lib/enums.h
@@ -33,13 +33,23 @@ namespace verbly {
33 undefined = -1, 33 undefined = -1,
34 notion = 0, 34 notion = 0,
35 word = 1, 35 word = 1,
36 group = 2, 36 frame = 2,
37 frame = 3, 37 part = 3,
38 lemma = 4, 38 lemma = 4,
39 form = 5, 39 form = 5,
40 pronunciation = 6 40 pronunciation = 6
41 }; 41 };
42 42
43 enum class part_type {
44 invalid = -1,
45 noun_phrase = 0,
46 verb = 1,
47 preposition = 2,
48 adjective = 3,
49 adverb = 4,
50 literal = 5
51 };
52
43}; 53};
44 54
45#endif /* end of include guard: ENUMS_H_260BA847 */ 55#endif /* end of include guard: ENUMS_H_260BA847 */
diff --git a/lib/field.cpp b/lib/field.cpp index deecb06..5b51ef4 100644 --- a/lib/field.cpp +++ b/lib/field.cpp
@@ -48,6 +48,11 @@ namespace verbly {
48 return filter(*this, filter::comparison::int_equals, static_cast<int>(value)); 48 return filter(*this, filter::comparison::int_equals, static_cast<int>(value));
49 } 49 }
50 50
51 filter field::operator==(part_type value) const
52 {
53 return filter(*this, filter::comparison::int_equals, static_cast<int>(value));
54 }
55
51 filter field::operator==(bool value) const 56 filter field::operator==(bool value) const
52 { 57 {
53 return filter(*this, filter::comparison::boolean_equals, value); 58 return filter(*this, filter::comparison::boolean_equals, value);
@@ -68,6 +73,21 @@ namespace verbly {
68 return filter(*this, filter::comparison::string_is_like, std::move(value)); 73 return filter(*this, filter::comparison::string_is_like, std::move(value));
69 } 74 }
70 75
76 filter field::operator==(const char* value) const
77 {
78 return filter(*this, filter::comparison::string_equals, std::string(value));
79 }
80
81 filter field::operator!=(const char* value) const
82 {
83 return filter(*this, filter::comparison::string_does_not_equal, std::string(value));
84 }
85
86 filter field::operator%=(const char* value) const
87 {
88 return filter(*this, filter::comparison::string_is_like, std::string(value));
89 }
90
71 field::operator filter() const 91 field::operator filter() const
72 { 92 {
73 if (isJoin()) 93 if (isJoin())
diff --git a/lib/field.h b/lib/field.h index f61e038..b4bf02d 100644 --- a/lib/field.h +++ b/lib/field.h
@@ -17,6 +17,7 @@ namespace verbly {
17 integer, 17 integer,
18 boolean, 18 boolean,
19 join, 19 join,
20 join_where,
20 join_through, 21 join_through,
21 hierarchal_join 22 hierarchal_join
22 }; 23 };
@@ -95,6 +96,17 @@ namespace verbly {
95 return field(obj, type::join, name, nullable, table); 96 return field(obj, type::join, name, nullable, table);
96 } 97 }
97 98
99 static field joinWhere(
100 object obj,
101 const char* name,
102 object joinWith,
103 const field& conditionField,
104 int conditionValue,
105 bool nullable = false)
106 {
107 return field(obj, type::join_where, name, nullable, 0, joinWith, 0, 0, 0, &conditionField, conditionValue);
108 }
109
98 static field joinThrough( 110 static field joinThrough(
99 object obj, 111 object obj,
100 const char* name, 112 const char* name,
@@ -151,7 +163,10 @@ namespace verbly {
151 163
152 bool isJoin() const 164 bool isJoin() const
153 { 165 {
154 return ((type_ == type::join) || (type_ == type::join_through) || (type_ == type::hierarchal_join)); 166 return ((type_ == type::join)
167 || (type_ == type::join_where)
168 || (type_ == type::join_through)
169 || (type_ == type::hierarchal_join));
155 } 170 }
156 171
157 const char* getColumn() const 172 const char* getColumn() const
@@ -180,7 +195,7 @@ namespace verbly {
180 { 195 {
181 return (type_ == type::hierarchal_join) 196 return (type_ == type::hierarchal_join)
182 ? object_ 197 ? object_
183 : ((type_ == type::join) || (type_ == type::join_through)) 198 : ((type_ == type::join) || (type_ == type::join_where) || (type_ == type::join_through))
184 ? joinObject_ 199 ? joinObject_
185 : throw std::domain_error("Non-join fields don't have join objects"); 200 : throw std::domain_error("Non-join fields don't have join objects");
186 } 201 }
@@ -209,6 +224,22 @@ namespace verbly {
209 : throw std::domain_error("Only many-to-many join fields have a foreign join column"); 224 : throw std::domain_error("Only many-to-many join fields have a foreign join column");
210 } 225 }
211 226
227 // Condition joins
228
229 const field& getConditionField() const
230 {
231 return (type_ == type::join_where)
232 ? *conditionField_
233 : throw std::domain_error("Only condition join fields have a condition field");
234 }
235
236 int getConditionValue() const
237 {
238 return (type_ == type::join_where)
239 ? conditionValue_
240 : throw std::domain_error("Only condition join fields have a condition value");
241 }
242
212 // Ordering 243 // Ordering
213 244
214 bool operator<(const field& other) const 245 bool operator<(const field& other) const
@@ -217,20 +248,30 @@ namespace verbly {
217 // However, there do exist a number of relationships from an object to 248 // However, there do exist a number of relationships from an object to
218 // itself, such as notion hypernymy/hyponymy. Hypernymy and hyponymy have 249 // itself, such as notion hypernymy/hyponymy. Hypernymy and hyponymy have
219 // the same object (notion), the same column (notion_id), and the same 250 // the same object (notion), the same column (notion_id), and the same
220 // table (hypernymy); however, they have different join columns. 251 // table (hypernymy); however, they have different join columns. For
221 return std::tie(object_, column_, table_, joinColumn_) < std::tie(other.object_, other.column_, other.table_, other.joinColumn_); 252 // condition joins, the condition field and condition value are also
253 // significant.
254 if (conditionField_)
255 {
256 return std::tie(object_, column_, table_, joinColumn_, *conditionField_, conditionValue_)
257 < std::tie(other.object_, other.column_, other.table_, other.joinColumn_, *other.conditionField_, other.conditionValue_);
258 } else {
259 return std::tie(object_, column_, table_, joinColumn_) < std::tie(other.object_, other.column_, other.table_, other.joinColumn_);
260 }
222 } 261 }
223 262
224 // Equality 263 // Equality
225 264
226 bool operator==(const field& other) const 265 bool operator==(const field& other) const
227 { 266 {
228 // For the most part, (object, column) uniquely identifies fields. 267 // See operator<() for documentation.
229 // However, there do exist a number of relationships from an object to 268 if (conditionField_)
230 // itself, such as notion hypernymy/hyponymy. Hypernymy and hyponymy have 269 {
231 // the same object (notion), the same column (notion_id), and the same 270 return std::tie(object_, column_, table_, joinColumn_, *conditionField_, conditionValue_)
232 // table (hypernymy); however, they have different join columns. 271 == std::tie(other.object_, other.column_, other.table_, other.joinColumn_, *other.conditionField_, other.conditionValue_);
233 return std::tie(object_, column_, table_, joinColumn_) == std::tie(other.object_, other.column_, other.table_, other.joinColumn_); 272 } else {
273 return std::tie(object_, column_, table_, joinColumn_) == std::tie(other.object_, other.column_, other.table_, other.joinColumn_);
274 }
234 } 275 }
235 276
236 // Filter construction 277 // Filter construction
@@ -245,6 +286,7 @@ namespace verbly {
245 filter operator==(part_of_speech value) const; // Part of speech equality 286 filter operator==(part_of_speech value) const; // Part of speech equality
246 filter operator==(positioning value) const; // Adjective positioning equality 287 filter operator==(positioning value) const; // Adjective positioning equality
247 filter operator==(inflection value) const; // Inflection category equality 288 filter operator==(inflection value) const; // Inflection category equality
289 filter operator==(part_type value) const; // Verb frame part type equality
248 290
249 filter operator==(bool value) const; // Boolean equality 291 filter operator==(bool value) const; // Boolean equality
250 292
@@ -252,6 +294,10 @@ namespace verbly {
252 filter operator!=(std::string value) const; // String inequality 294 filter operator!=(std::string value) const; // String inequality
253 filter operator%=(std::string value) const; // String matching 295 filter operator%=(std::string value) const; // String matching
254 296
297 filter operator==(const char* value) const; // String equality
298 filter operator!=(const char* value) const; // String inequality
299 filter operator%=(const char* value) const; // String matching
300
255 operator filter() const; // Non-nullity 301 operator filter() const; // Non-nullity
256 filter operator!() const; // Nullity 302 filter operator!() const; // Nullity
257 303
@@ -270,7 +316,9 @@ namespace verbly {
270 object joinObject = object::undefined, 316 object joinObject = object::undefined,
271 const char* foreignColumn = 0, 317 const char* foreignColumn = 0,
272 const char* joinColumn = 0, 318 const char* joinColumn = 0,
273 const char* foreignJoinColumn = 0) : 319 const char* foreignJoinColumn = 0,
320 const field* conditionField = 0,
321 int conditionValue = 0) :
274 object_(obj), 322 object_(obj),
275 type_(datatype), 323 type_(datatype),
276 column_(column), 324 column_(column),
@@ -279,7 +327,9 @@ namespace verbly {
279 joinObject_(joinObject), 327 joinObject_(joinObject),
280 foreignColumn_(foreignColumn), 328 foreignColumn_(foreignColumn),
281 joinColumn_(joinColumn), 329 joinColumn_(joinColumn),
282 foreignJoinColumn_(foreignJoinColumn) 330 foreignJoinColumn_(foreignJoinColumn),
331 conditionField_(conditionField),
332 conditionValue_(conditionValue)
283 { 333 {
284 } 334 }
285 335
@@ -300,6 +350,10 @@ namespace verbly {
300 const char* joinColumn_ = 0; 350 const char* joinColumn_ = 0;
301 const char* foreignJoinColumn_ = 0; 351 const char* foreignJoinColumn_ = 0;
302 352
353 // Condition joins
354 const field* conditionField_ = 0;
355 int conditionValue_ = 0;
356
303 }; 357 };
304 358
305}; 359};
diff --git a/lib/filter.cpp b/lib/filter.cpp index ceb9327..ab46df2 100644 --- a/lib/filter.cpp +++ b/lib/filter.cpp
@@ -3,8 +3,8 @@
3#include <map> 3#include <map>
4#include "notion.h" 4#include "notion.h"
5#include "word.h" 5#include "word.h"
6#include "group.h"
7#include "frame.h" 6#include "frame.h"
7#include "part.h"
8#include "lemma.h" 8#include "lemma.h"
9#include "form.h" 9#include "form.h"
10#include "pronunciation.h" 10#include "pronunciation.h"
@@ -594,6 +594,7 @@ namespace verbly {
594 switch (joinOn.getType()) 594 switch (joinOn.getType())
595 { 595 {
596 case field::type::join: 596 case field::type::join:
597 case field::type::join_where:
597 case field::type::join_through: 598 case field::type::join_through:
598 { 599 {
599 switch (filterType) 600 switch (filterType)
@@ -1108,8 +1109,8 @@ namespace verbly {
1108 } 1109 }
1109 1110
1110 case object::word: 1111 case object::word:
1111 case object::group:
1112 case object::frame: 1112 case object::frame:
1113 case object::part:
1113 case object::lemma: 1114 case object::lemma:
1114 case object::form: 1115 case object::form:
1115 case object::pronunciation: 1116 case object::pronunciation:
@@ -1134,10 +1135,10 @@ namespace verbly {
1134 return *this; 1135 return *this;
1135 } 1136 }
1136 1137
1137 case object::group:
1138 case object::frame: 1138 case object::frame:
1139 case object::part:
1139 { 1140 {
1140 return (verbly::word::group %= *this); 1141 return (verbly::word::frame %= *this);
1141 } 1142 }
1142 1143
1143 case object::lemma: 1144 case object::lemma:
@@ -1148,12 +1149,12 @@ namespace verbly {
1148 } 1149 }
1149 } 1150 }
1150 1151
1151 case object::group: 1152 case object::frame:
1152 { 1153 {
1153 switch (singleton_.filterField.getObject()) 1154 switch (singleton_.filterField.getObject())
1154 { 1155 {
1155 case object::undefined: 1156 case object::undefined:
1156 case object::group: 1157 case object::frame:
1157 { 1158 {
1158 return *this; 1159 return *this;
1159 } 1160 }
@@ -1164,34 +1165,34 @@ namespace verbly {
1164 case object::form: 1165 case object::form:
1165 case object::pronunciation: 1166 case object::pronunciation:
1166 { 1167 {
1167 return (verbly::group::word %= *this); 1168 return (verbly::frame::word %= *this);
1168 } 1169 }
1169 1170
1170 case object::frame: 1171 case object::part:
1171 { 1172 {
1172 return (verbly::group::frame %= *this); 1173 return (verbly::frame::part() %= *this);
1173 } 1174 }
1174 } 1175 }
1175 } 1176 }
1176 1177
1177 case object::frame: 1178 case object::part:
1178 { 1179 {
1179 switch (singleton_.filterField.getObject()) 1180 switch (singleton_.filterField.getObject())
1180 { 1181 {
1181 case object::undefined: 1182 case object::undefined:
1182 case object::frame: 1183 case object::part:
1183 { 1184 {
1184 return *this; 1185 return *this;
1185 } 1186 }
1186 1187
1187 case object::notion: 1188 case object::notion:
1188 case object::word: 1189 case object::word:
1189 case object::group: 1190 case object::frame:
1190 case object::lemma: 1191 case object::lemma:
1191 case object::form: 1192 case object::form:
1192 case object::pronunciation: 1193 case object::pronunciation:
1193 { 1194 {
1194 return (verbly::frame::group %= *this); 1195 return (verbly::part::frame %= *this);
1195 } 1196 }
1196 } 1197 }
1197 } 1198 }
@@ -1202,8 +1203,8 @@ namespace verbly {
1202 { 1203 {
1203 case object::notion: 1204 case object::notion:
1204 case object::word: 1205 case object::word:
1205 case object::group:
1206 case object::frame: 1206 case object::frame:
1207 case object::part:
1207 { 1208 {
1208 return verbly::lemma::word %= *this; 1209 return verbly::lemma::word %= *this;
1209 } 1210 }
@@ -1228,11 +1229,11 @@ namespace verbly {
1228 { 1229 {
1229 case object::notion: 1230 case object::notion:
1230 case object::word: 1231 case object::word:
1231 case object::group:
1232 case object::frame: 1232 case object::frame:
1233 case object::part:
1233 case object::lemma: 1234 case object::lemma:
1234 { 1235 {
1235 return verbly::form::lemma(inflection::base) %= *this; 1236 return verbly::form::lemma %= *this;
1236 } 1237 }
1237 1238
1238 case object::undefined: 1239 case object::undefined:
@@ -1254,8 +1255,8 @@ namespace verbly {
1254 { 1255 {
1255 case object::notion: 1256 case object::notion:
1256 case object::word: 1257 case object::word:
1257 case object::group:
1258 case object::frame: 1258 case object::frame:
1259 case object::part:
1259 case object::lemma: 1260 case object::lemma:
1260 case object::form: 1261 case object::form:
1261 { 1262 {
diff --git a/lib/form.cpp b/lib/form.cpp index 5d4c343..4811f14 100644 --- a/lib/form.cpp +++ b/lib/form.cpp
@@ -16,11 +16,9 @@ namespace verbly {
16 const field form::complexity = field::integerField(object::form, "complexity"); 16 const field form::complexity = field::integerField(object::form, "complexity");
17 const field form::proper = field::booleanField(object::form, "proper"); 17 const field form::proper = field::booleanField(object::form, "proper");
18 18
19 const field form::lemma = field::joinField(object::form, "form_id", object::lemma);
19 const field form::pronunciation = field::joinThrough(object::form, "form_id", object::pronunciation, "forms_pronunciations", "pronunciation_id"); 20 const field form::pronunciation = field::joinThrough(object::form, "form_id", object::pronunciation, "forms_pronunciations", "pronunciation_id");
20 21
21 const field form::lemmaJoin = field::joinField(object::form, "form_id", object::lemma);
22 const field form::inflectionCategory = field::integerField("lemmas_forms", "category");
23
24 form::form(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true) 22 form::form(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
25 { 23 {
26 id_ = sqlite3_column_int(row, 0); 24 id_ = sqlite3_column_int(row, 0);
@@ -29,16 +27,6 @@ namespace verbly {
29 proper_ = (sqlite3_column_int(row, 3) == 1); 27 proper_ = (sqlite3_column_int(row, 3) == 1);
30 } 28 }
31 29
32 filter operator%=(form::inflection_field check, filter joinCondition)
33 {
34 return (form::lemmaJoin %= (joinCondition && (form::inflectionCategory == check.getCategory())));
35 }
36
37 form::inflection_field::operator filter() const
38 {
39 return (form::lemmaJoin %= (form::inflectionCategory == category_));
40 }
41
42 const std::vector<pronunciation>& form::getPronunciations() const 30 const std::vector<pronunciation>& form::getPronunciations() const
43 { 31 {
44 if (!valid_) 32 if (!valid_)
@@ -48,7 +36,7 @@ namespace verbly {
48 36
49 if (!initializedPronunciations_) 37 if (!initializedPronunciations_)
50 { 38 {
51 pronunciations_ = db_->pronunciations(pronunciation::form %= *this, false, -1).all(); 39 pronunciations_ = db_->pronunciations(pronunciation::form %= *this, verbly::pronunciation::id, -1).all();
52 initializedPronunciations_ = true; 40 initializedPronunciations_ = true;
53 } 41 }
54 42
diff --git a/lib/form.h b/lib/form.h index aca5b2f..cf64117 100644 --- a/lib/form.h +++ b/lib/form.h
@@ -104,33 +104,9 @@ namespace verbly {
104 104
105 // Relationships to other objects 105 // Relationships to other objects
106 106
107 static const field pronunciation; 107 static const field lemma;
108
109 class inflection_field {
110 public:
111
112 inflection_field(inflection category) : category_(category)
113 {
114 }
115
116 const inflection getCategory() const
117 {
118 return category_;
119 }
120 108
121 operator filter() const; 109 static const field pronunciation;
122
123 private:
124
125 const inflection category_;
126 };
127
128 static const inflection_field lemma(inflection category)
129 {
130 return inflection_field(category);
131 }
132
133 friend filter operator%=(form::inflection_field check, filter joinCondition);
134 110
135 private: 111 private:
136 bool valid_ = false; 112 bool valid_ = false;
@@ -145,9 +121,6 @@ namespace verbly {
145 mutable bool initializedPronunciations_ = false; 121 mutable bool initializedPronunciations_ = false;
146 mutable std::vector<class pronunciation> pronunciations_; 122 mutable std::vector<class pronunciation> pronunciations_;
147 123
148 static const field lemmaJoin;
149 static const field inflectionCategory;
150
151 }; 124 };
152 125
153}; 126};
diff --git a/lib/frame.cpp b/lib/frame.cpp index 8cab56b..a73fbda 100644 --- a/lib/frame.cpp +++ b/lib/frame.cpp
@@ -1,95 +1,36 @@
1#include "frame.h" 1#include "frame.h"
2#include <sqlite3.h> 2#include <sqlite3.h>
3#include <json.hpp> 3#include "database.h"
4#include "query.h"
4 5
5namespace verbly { 6namespace verbly {
6 7
7 const object frame::objectType = object::frame; 8 const object frame::objectType = object::frame;
8 9
9 const std::list<std::string> frame::select = {"frame_id", "data"}; 10 const std::list<std::string> frame::select = {"frame_id", "group_id", "length"};
10 11
11 const field frame::id = field::integerField(object::frame, "frame_id"); 12 const field frame::id = field::integerField(object::frame, "frame_id");
13 const field frame::length = field::integerField(object::frame, "length");
12 14
13 const field frame::group = field::joinThrough(object::frame, "frame_id", object::group, "groups_frames", "group_id"); 15 const field frame::word = field::joinField(object::frame, "group_id", object::word);
14 16
15 frame::frame(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true) 17 field frame::part()
16 { 18 {
17 id_ = sqlite3_column_int(row, 0); 19 return field::joinField(object::frame, "frame_id", object::part);
18 20 }
19 std::string partsJsonStr(reinterpret_cast<const char*>(sqlite3_column_blob(row, 1)));
20 nlohmann::json partsJson = nlohmann::json::parse(std::move(partsJsonStr));
21
22 for (const nlohmann::json& partJson : partsJson)
23 {
24 part::type partType = static_cast<part::type>(partJson["type"].get<int>());
25
26 switch (partType)
27 {
28 case part::type::noun_phrase:
29 {
30 std::set<std::string> synrestrs;
31 for (const nlohmann::json& synrestrJson : partJson["synrestrs"])
32 {
33 synrestrs.insert(synrestrJson.get<std::string>());
34 }
35
36 parts_.push_back(part::createNounPhrase(
37 partJson["role"].get<std::string>(),
38 selrestr(partJson["selrestrs"]),
39 std::move(synrestrs)));
40
41 break;
42 }
43
44 case part::type::preposition:
45 {
46 std::vector<std::string> choices;
47 for (const nlohmann::json& choiceJson : partJson["choices"])
48 {
49 choices.push_back(choiceJson.get<std::string>());
50 }
51
52 parts_.push_back(part::createPreposition(
53 std::move(choices),
54 partJson["literal"].get<bool>()));
55
56 break;
57 }
58
59 case part::type::verb:
60 {
61 parts_.push_back(part::createVerb());
62
63 break;
64 }
65
66 case part::type::adjective:
67 {
68 parts_.push_back(part::createAdjective());
69
70 break;
71 }
72
73 case part::type::adverb:
74 {
75 parts_.push_back(part::createAdverb());
76
77 break;
78 }
79 21
80 case part::type::literal: 22 field frame::part(int index)
81 { 23 {
82 parts_.push_back(part::createLiteral(partJson["value"].get<std::string>())); 24 return field::joinWhere(object::frame, "frame_id", object::part, part::index, index);
25 }
83 26
84 break; 27 frame::frame(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
85 } 28 {
29 id_ = sqlite3_column_int(row, 0);
30 groupId_ = sqlite3_column_int(row, 1);
31 length_ = sqlite3_column_int(row, 2);
86 32
87 case part::type::invalid: 33 parts_ = db.parts(*this, verbly::part::index, -1).all();
88 {
89 throw std::domain_error("Invalid part data");
90 }
91 }
92 }
93 } 34 }
94 35
95}; 36};
diff --git a/lib/frame.h b/lib/frame.h index 97473a0..36e179e 100644 --- a/lib/frame.h +++ b/lib/frame.h
@@ -41,6 +41,16 @@ namespace verbly {
41 return id_; 41 return id_;
42 } 42 }
43 43
44 int getLength() const
45 {
46 if (!valid_)
47 {
48 throw std::domain_error("Bad access to uninitialized frame");
49 }
50
51 return length_;
52 }
53
44 const std::vector<part>& getParts() const 54 const std::vector<part>& getParts() const
45 { 55 {
46 if (!valid_) 56 if (!valid_)
@@ -61,6 +71,8 @@ namespace verbly {
61 71
62 static const field id; 72 static const field id;
63 73
74 static const field length;
75
64 operator filter() const 76 operator filter() const
65 { 77 {
66 if (!valid_) 78 if (!valid_)
@@ -73,13 +85,18 @@ namespace verbly {
73 85
74 // Relationships to other objects 86 // Relationships to other objects
75 87
76 static const field group; 88 static const field word;
89
90 static field part();
91 static field part(int index);
77 92
78 private: 93 private:
79 bool valid_ = false; 94 bool valid_ = false;
80 95
81 int id_; 96 int id_;
82 std::vector<part> parts_; 97 int groupId_;
98 int length_;
99 std::vector<class part> parts_;
83 100
84 const database* db_; 101 const database* db_;
85 102
diff --git a/lib/group.cpp b/lib/group.cpp deleted file mode 100644 index d5790e9..0000000 --- a/lib/group.cpp +++ /dev/null
@@ -1,61 +0,0 @@
1#include "group.h"
2#include <sqlite3.h>
3#include <json.hpp>
4#include "database.h"
5#include "query.h"
6
7namespace verbly {
8
9 const object group::objectType = object::group;
10
11 const std::list<std::string> group::select = {"group_id", "data"};
12
13 const field group::id = field::integerField(object::group, "group_id");
14
15 const field group::frame = field::joinThrough(object::group, "group_id", object::frame, "groups_frames", "frame_id");
16 const field group::word = field::joinField(object::group, "group_id", object::word);
17
18 group::group(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
19 {
20 id_ = sqlite3_column_int(row, 0);
21
22 std::string rolesJsonStr(reinterpret_cast<const char*>(sqlite3_column_blob(row, 1)));
23 nlohmann::json rolesJson = nlohmann::json::parse(std::move(rolesJsonStr));
24 for (const nlohmann::json& roleJson : rolesJson)
25 {
26 std::string roleName = roleJson["type"];
27 selrestr roleSelrestr;
28
29 if (roleJson.find("selrestrs") != roleJson.end())
30 {
31 roleSelrestr = selrestr(roleJson["selrestrs"]);
32 }
33
34 roles_[roleName] = role(roleName, std::move(roleSelrestr));
35 }
36 }
37
38 const std::vector<frame>& group::getFrames() const
39 {
40 if (!valid_)
41 {
42 throw std::domain_error("Bad access to uninitialized group");
43 }
44
45 if (!initializedFrames_)
46 {
47 frames_ = db_->frames(frame::group %= *this, false, -1).all();
48
49 initializedFrames_ = true;
50 }
51
52 return frames_;
53 }
54
55 const role& group::getRole(std::string roleName) const
56 {
57 return roles_.at(roleName);
58 }
59
60};
61
diff --git a/lib/group.h b/lib/group.h deleted file mode 100644 index fe62d39..0000000 --- a/lib/group.h +++ /dev/null
@@ -1,91 +0,0 @@
1#ifndef GROUP_H_BD6933C0
2#define GROUP_H_BD6933C0
3
4#include <stdexcept>
5#include <list>
6#include <vector>
7#include "field.h"
8#include "filter.h"
9#include "frame.h"
10#include "role.h"
11
12struct sqlite3_stmt;
13
14namespace verbly {
15
16 class database;
17
18 class group {
19 public:
20
21 // Default constructor
22
23 group() = default;
24
25 // Construct from database
26
27 group(const database& db, sqlite3_stmt* row);
28
29 // Accessors
30
31 operator bool() const
32 {
33 return valid_;
34 }
35
36 int getId() const
37 {
38 if (!valid_)
39 {
40 throw std::domain_error("Bad access to uninitialized group");
41 }
42
43 return id_;
44 }
45
46 const std::vector<frame>& getFrames() const;
47
48 const role& getRole(std::string roleName) const;
49
50 // Type info
51
52 static const object objectType;
53
54 static const std::list<std::string> select;
55
56 // Query fields
57
58 static const field id;
59
60 operator filter() const
61 {
62 if (!valid_)
63 {
64 throw std::domain_error("Bad access to uninitialized group");
65 }
66
67 return (id == id_);
68 }
69
70 // Relationships to other objects
71
72 static const field frame;
73
74 static const field word;
75
76 private:
77 bool valid_ = false;
78
79 int id_;
80 std::map<std::string, role> roles_;
81
82 const database* db_;
83
84 mutable bool initializedFrames_ = false;
85 mutable std::vector<class frame> frames_;
86
87 };
88
89};
90
91#endif /* end of include guard: GROUP_H_BD6933C0 */
diff --git a/lib/lemma.cpp b/lib/lemma.cpp index 1601460..0c6e99e 100644 --- a/lib/lemma.cpp +++ b/lib/lemma.cpp
@@ -10,20 +10,13 @@ namespace verbly {
10 const std::list<std::string> lemma::select = {"lemma_id"}; 10 const std::list<std::string> lemma::select = {"lemma_id"};
11 11
12 const field lemma::id = field::integerField(object::lemma, "lemma_id"); 12 const field lemma::id = field::integerField(object::lemma, "lemma_id");
13
14 const field lemma::word = field::joinField(object::lemma, "lemma_id", object::word);
15
16 const field lemma::formJoin = field::joinField(object::lemma, "form_id", object::form);
17 const field lemma::inflectionCategory = field::integerField(object::lemma, "category"); 13 const field lemma::inflectionCategory = field::integerField(object::lemma, "category");
18 14
19 filter operator%=(lemma::inflection_field check, filter joinCondition) 15 const field lemma::word = field::joinField(object::lemma, "lemma_id", object::word);
20 {
21 return (lemma::formJoin %= joinCondition) && (lemma::inflectionCategory == check.getCategory());
22 }
23 16
24 lemma::inflection_field::operator filter() const 17 field lemma::form(inflection category)
25 { 18 {
26 return (lemma::inflectionCategory == category_); 19 return field::joinWhere(object::lemma, "form_id", object::form, inflectionCategory, static_cast<int>(category));
27 } 20 }
28 21
29 lemma::lemma(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true) 22 lemma::lemma(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
@@ -68,7 +61,7 @@ namespace verbly {
68 61
69 void lemma::initializeForm(inflection infl) const 62 void lemma::initializeForm(inflection infl) const
70 { 63 {
71 forms_[infl] = db_->forms(form::lemma(infl) %= *this, false, -1).all(); 64 forms_[infl] = db_->forms(form::lemma %= ((inflectionCategory == infl) && *this), verbly::form::id, -1).all();
72 } 65 }
73 66
74}; 67};
diff --git a/lib/lemma.h b/lib/lemma.h index 407fa3c..56cfc56 100644 --- a/lib/lemma.h +++ b/lib/lemma.h
@@ -74,31 +74,7 @@ namespace verbly {
74 74
75 static const field word; 75 static const field word;
76 76
77 class inflection_field { 77 static field form(inflection category);
78 public:
79
80 inflection_field(inflection category) : category_(category)
81 {
82 }
83
84 const inflection getCategory() const
85 {
86 return category_;
87 }
88
89 operator filter() const;
90
91 private:
92
93 const inflection category_;
94 };
95
96 static const inflection_field form(inflection category)
97 {
98 return inflection_field(category);
99 }
100
101 friend filter operator%=(lemma::inflection_field check, filter joinCondition);
102 78
103 private: 79 private:
104 80
@@ -112,7 +88,6 @@ namespace verbly {
112 88
113 const database* db_; 89 const database* db_;
114 90
115 static const field formJoin;
116 static const field inflectionCategory; 91 static const field inflectionCategory;
117 92
118 }; 93 };
diff --git a/lib/order.h b/lib/order.h new file mode 100644 index 0000000..d2f0f92 --- /dev/null +++ b/lib/order.h
@@ -0,0 +1,69 @@
1#ifndef ORDER_H_0EC669D5
2#define ORDER_H_0EC669D5
3
4#include <stdexcept>
5#include "field.h"
6
7namespace verbly {
8
9 class order {
10 public:
11 enum class type {
12 random,
13 field
14 };
15
16 // Type
17
18 type getType() const
19 {
20 return type_;
21 }
22
23 // Random
24
25 order() : type_(type::random)
26 {
27 }
28
29 // Field
30
31 order(
32 field arg,
33 bool asc = true) :
34 type_(type::field),
35 sortField_(std::move(arg)),
36 ascending_(asc)
37 {
38 }
39
40 field getSortField() const
41 {
42 if (type_ != type::field)
43 {
44 throw std::domain_error("Invalid access to non-field order");
45 }
46
47 return sortField_;
48 }
49
50 bool isAscending() const
51 {
52 if (type_ != type::field)
53 {
54 throw std::domain_error("Invalid access to non-field order");
55 }
56
57 return ascending_;
58 }
59
60 private:
61 type type_;
62 field sortField_;
63 bool ascending_;
64
65 };
66
67};
68
69#endif /* end of include guard: ORDER_H_0EC669D5 */
diff --git a/lib/part.cpp b/lib/part.cpp index e66d151..1fbb24d 100644 --- a/lib/part.cpp +++ b/lib/part.cpp
@@ -1,12 +1,30 @@
1#include "part.h" 1#include "part.h"
2#include <stdexcept> 2#include <stdexcept>
3#include <sqlite3.h>
3#include "selrestr.h" 4#include "selrestr.h"
5#include "database.h"
4 6
5namespace verbly { 7namespace verbly {
6 8
9 const object part::objectType = object::part;
10
11 const std::list<std::string> part::select = {"part_id", "frame_id", "part_index", "type", "role", "selrestrs", "prepositions", "preposition_literality", "literal_value"};
12
13 const field part::index = field::integerField(object::part, "part_index");
14 const field part::type = field::integerField(object::part, "type");
15
16 const field part::role = field::stringField(object::part, "role", true);
17
18 const field part::frame = field::joinField(object::part, "frame_id", object::frame);
19
20 const field part::synrestr_field::synrestrJoin = field::joinField(object::part, "part_id", "synrestrs");
21 const field part::synrestr_field::synrestrField = field::stringField("synrestrs", "synrestr");
22
23 const part::synrestr_field part::synrestr = {};
24
7 part part::createNounPhrase(std::string role, selrestr selrestrs, std::set<std::string> synrestrs) 25 part part::createNounPhrase(std::string role, selrestr selrestrs, std::set<std::string> synrestrs)
8 { 26 {
9 part p(type::noun_phrase); 27 part p(part_type::noun_phrase);
10 28
11 new(&p.noun_phrase_.role) std::string(std::move(role)); 29 new(&p.noun_phrase_.role) std::string(std::move(role));
12 new(&p.noun_phrase_.selrestrs) selrestr(std::move(selrestrs)); 30 new(&p.noun_phrase_.selrestrs) selrestr(std::move(selrestrs));
@@ -17,12 +35,12 @@ namespace verbly {
17 35
18 part part::createVerb() 36 part part::createVerb()
19 { 37 {
20 return part(type::verb); 38 return part(part_type::verb);
21 } 39 }
22 40
23 part part::createPreposition(std::vector<std::string> choices, bool literal) 41 part part::createPreposition(std::vector<std::string> choices, bool literal)
24 { 42 {
25 part p(type::preposition); 43 part p(part_type::preposition);
26 44
27 new(&p.preposition_.choices) std::vector<std::string>(std::move(choices)); 45 new(&p.preposition_.choices) std::vector<std::string>(std::move(choices));
28 p.preposition_.literal = literal; 46 p.preposition_.literal = literal;
@@ -32,30 +50,79 @@ namespace verbly {
32 50
33 part part::createAdjective() 51 part part::createAdjective()
34 { 52 {
35 return part(type::adjective); 53 return part(part_type::adjective);
36 } 54 }
37 55
38 part part::createAdverb() 56 part part::createAdverb()
39 { 57 {
40 return part(type::adverb); 58 return part(part_type::adverb);
41 } 59 }
42 60
43 part part::createLiteral(std::string value) 61 part part::createLiteral(std::string value)
44 { 62 {
45 part p(type::literal); 63 part p(part_type::literal);
46 64
47 new(&p.literal_) std::string(std::move(value)); 65 new(&p.literal_) std::string(std::move(value));
48 66
49 return p; 67 return p;
50 } 68 }
51 69
70 part::part(const database& db, sqlite3_stmt* row)
71 {
72 int id = sqlite3_column_int(row, 0);
73
74 type_ = static_cast<part_type>(sqlite3_column_int(row, 3));
75
76 switch (type_)
77 {
78 case part_type::noun_phrase:
79 {
80 new(&noun_phrase_.role) std::string(reinterpret_cast<const char*>(sqlite3_column_blob(row, 4)));
81 new(&noun_phrase_.selrestrs) selrestr(nlohmann::json::parse(reinterpret_cast<const char*>(sqlite3_column_blob(row, 5))));
82 new(&noun_phrase_.synrestrs) std::set<std::string>(db.synrestrs(id));
83
84 break;
85 }
86
87 case part_type::preposition:
88 {
89 new(&preposition_.choices) std::vector<std::string>();
90 preposition_.literal = (sqlite3_column_int(row, 7) == 1);
91
92 std::string choicesJsonStr(reinterpret_cast<const char*>(sqlite3_column_blob(row, 6)));
93 nlohmann::json choicesJson = nlohmann::json::parse(std::move(choicesJsonStr));
94 for (const nlohmann::json& choiceJson : choicesJson)
95 {
96 preposition_.choices.push_back(choiceJson.get<std::string>());
97 }
98
99 break;
100 }
101
102 case part_type::literal:
103 {
104 new(&literal_) std::string(reinterpret_cast<const char*>(sqlite3_column_blob(row, 8)));
105
106 break;
107 }
108
109 case part_type::verb:
110 case part_type::adjective:
111 case part_type::adverb:
112 case part_type::invalid:
113 {
114 break;
115 }
116 }
117 }
118
52 part::part(const part& other) 119 part::part(const part& other)
53 { 120 {
54 type_ = other.type_; 121 type_ = other.type_;
55 122
56 switch (type_) 123 switch (type_)
57 { 124 {
58 case type::noun_phrase: 125 case part_type::noun_phrase:
59 { 126 {
60 new(&noun_phrase_.role) std::string(other.noun_phrase_.role); 127 new(&noun_phrase_.role) std::string(other.noun_phrase_.role);
61 new(&noun_phrase_.selrestrs) selrestr(other.noun_phrase_.selrestrs); 128 new(&noun_phrase_.selrestrs) selrestr(other.noun_phrase_.selrestrs);
@@ -64,7 +131,7 @@ namespace verbly {
64 break; 131 break;
65 } 132 }
66 133
67 case type::preposition: 134 case part_type::preposition:
68 { 135 {
69 new(&preposition_.choices) std::vector<std::string>(other.preposition_.choices); 136 new(&preposition_.choices) std::vector<std::string>(other.preposition_.choices);
70 preposition_.literal = other.preposition_.literal; 137 preposition_.literal = other.preposition_.literal;
@@ -72,17 +139,17 @@ namespace verbly {
72 break; 139 break;
73 } 140 }
74 141
75 case type::literal: 142 case part_type::literal:
76 { 143 {
77 new(&literal_) std::string(other.literal_); 144 new(&literal_) std::string(other.literal_);
78 145
79 break; 146 break;
80 } 147 }
81 148
82 case type::verb: 149 case part_type::verb:
83 case type::adjective: 150 case part_type::adjective:
84 case type::adverb: 151 case part_type::adverb:
85 case type::invalid: 152 case part_type::invalid:
86 { 153 {
87 break; 154 break;
88 } 155 }
@@ -103,7 +170,7 @@ namespace verbly {
103 170
104 void swap(part& first, part& second) 171 void swap(part& first, part& second)
105 { 172 {
106 using type = part::type; 173 using type = part_type;
107 174
108 type tempType = first.type_; 175 type tempType = first.type_;
109 std::string tempRole; 176 std::string tempRole;
@@ -231,7 +298,7 @@ namespace verbly {
231 { 298 {
232 switch (type_) 299 switch (type_)
233 { 300 {
234 case type::noun_phrase: 301 case part_type::noun_phrase:
235 { 302 {
236 using string_type = std::string; 303 using string_type = std::string;
237 using set_type = std::set<std::string>; 304 using set_type = std::set<std::string>;
@@ -243,7 +310,7 @@ namespace verbly {
243 break; 310 break;
244 } 311 }
245 312
246 case type::preposition: 313 case part_type::preposition:
247 { 314 {
248 using vector_type = std::vector<std::string>; 315 using vector_type = std::vector<std::string>;
249 316
@@ -252,7 +319,7 @@ namespace verbly {
252 break; 319 break;
253 } 320 }
254 321
255 case type::literal: 322 case part_type::literal:
256 { 323 {
257 using string_type = std::string; 324 using string_type = std::string;
258 325
@@ -261,10 +328,10 @@ namespace verbly {
261 break; 328 break;
262 } 329 }
263 330
264 case type::verb: 331 case part_type::verb:
265 case type::adjective: 332 case part_type::adjective:
266 case type::adverb: 333 case part_type::adverb:
267 case type::invalid: 334 case part_type::invalid:
268 { 335 {
269 break; 336 break;
270 } 337 }
@@ -273,7 +340,7 @@ namespace verbly {
273 340
274 std::string part::getNounRole() const 341 std::string part::getNounRole() const
275 { 342 {
276 if (type_ == type::noun_phrase) 343 if (type_ == part_type::noun_phrase)
277 { 344 {
278 return noun_phrase_.role; 345 return noun_phrase_.role;
279 } else { 346 } else {
@@ -283,7 +350,7 @@ namespace verbly {
283 350
284 selrestr part::getNounSelrestrs() const 351 selrestr part::getNounSelrestrs() const
285 { 352 {
286 if (type_ == type::noun_phrase) 353 if (type_ == part_type::noun_phrase)
287 { 354 {
288 return noun_phrase_.selrestrs; 355 return noun_phrase_.selrestrs;
289 } else { 356 } else {
@@ -293,7 +360,7 @@ namespace verbly {
293 360
294 std::set<std::string> part::getNounSynrestrs() const 361 std::set<std::string> part::getNounSynrestrs() const
295 { 362 {
296 if (type_ == type::noun_phrase) 363 if (type_ == part_type::noun_phrase)
297 { 364 {
298 return noun_phrase_.synrestrs; 365 return noun_phrase_.synrestrs;
299 } else { 366 } else {
@@ -303,7 +370,7 @@ namespace verbly {
303 370
304 bool part::nounHasSynrestr(std::string synrestr) const 371 bool part::nounHasSynrestr(std::string synrestr) const
305 { 372 {
306 if (type_ != type::noun_phrase) 373 if (type_ != part_type::noun_phrase)
307 { 374 {
308 throw std::domain_error("part::nounHasSynrestr is only valid for noun phrase parts"); 375 throw std::domain_error("part::nounHasSynrestr is only valid for noun phrase parts");
309 } 376 }
@@ -313,7 +380,7 @@ namespace verbly {
313 380
314 std::vector<std::string> part::getPrepositionChoices() const 381 std::vector<std::string> part::getPrepositionChoices() const
315 { 382 {
316 if (type_ == type::preposition) 383 if (type_ == part_type::preposition)
317 { 384 {
318 return preposition_.choices; 385 return preposition_.choices;
319 } else { 386 } else {
@@ -323,7 +390,7 @@ namespace verbly {
323 390
324 bool part::isPrepositionLiteral() const 391 bool part::isPrepositionLiteral() const
325 { 392 {
326 if (type_ == type::preposition) 393 if (type_ == part_type::preposition)
327 { 394 {
328 return preposition_.literal; 395 return preposition_.literal;
329 } else { 396 } else {
@@ -333,7 +400,7 @@ namespace verbly {
333 400
334 std::string part::getLiteralValue() const 401 std::string part::getLiteralValue() const
335 { 402 {
336 if (type_ == type::literal) 403 if (type_ == part_type::literal)
337 { 404 {
338 return literal_; 405 return literal_;
339 } else { 406 } else {
@@ -341,4 +408,9 @@ namespace verbly {
341 } 408 }
342 } 409 }
343 410
411 filter part::synrestr_field::operator%=(std::string synrestr) const
412 {
413 return (synrestrJoin %= (synrestrField == synrestr));
414 }
415
344}; 416};
diff --git a/lib/part.h b/lib/part.h index 3a15638..9a01312 100644 --- a/lib/part.h +++ b/lib/part.h
@@ -4,21 +4,20 @@
4#include <string> 4#include <string>
5#include <vector> 5#include <vector>
6#include <set> 6#include <set>
7#include <list>
7#include "selrestr.h" 8#include "selrestr.h"
9#include "field.h"
10#include "filter.h"
11#include "enums.h"
12
13struct sqlite3_stmt;
8 14
9namespace verbly { 15namespace verbly {
10 16
17 class database;
18
11 class part { 19 class part {
12 public: 20 public:
13 enum class type {
14 invalid = -1,
15 noun_phrase = 0,
16 verb = 1,
17 preposition = 2,
18 adjective = 3,
19 adverb = 4,
20 literal = 5
21 };
22 21
23 // Static factories 22 // Static factories
24 23
@@ -40,6 +39,10 @@ namespace verbly {
40 { 39 {
41 } 40 }
42 41
42 // Construct from database
43
44 part(const database& db, sqlite3_stmt* row);
45
43 // Copy and move constructors 46 // Copy and move constructors
44 47
45 part(const part& other); 48 part(const part& other);
@@ -60,7 +63,12 @@ namespace verbly {
60 63
61 // General accessors 64 // General accessors
62 65
63 type getType() const 66 operator bool() const
67 {
68 return (type_ != part_type::invalid);
69 }
70
71 part_type getType() const
64 { 72 {
65 return type_; 73 return type_;
66 } 74 }
@@ -85,11 +93,43 @@ namespace verbly {
85 93
86 std::string getLiteralValue() const; 94 std::string getLiteralValue() const;
87 95
96 // Type info
97
98 static const object objectType;
99
100 static const std::list<std::string> select;
101
102 // Query fields
103
104 static const field index;
105 static const field type;
106
107 static const field role;
108
109 // Relationships to other objects
110
111 static const field frame;
112
113 // Noun synrestr relationship
114
115 class synrestr_field {
116 public:
117
118 filter operator%=(std::string synrestr) const;
119
120 private:
121
122 static const field synrestrJoin;
123 static const field synrestrField;
124 };
125
126 static const synrestr_field synrestr;
127
88 private: 128 private:
89 129
90 // Private constructors 130 // Private constructors
91 131
92 part(type t) : type_(t) 132 part(part_type t) : type_(t)
93 { 133 {
94 } 134 }
95 135
@@ -108,7 +148,7 @@ namespace verbly {
108 std::string literal_; 148 std::string literal_;
109 }; 149 };
110 150
111 type type_ = type::invalid; 151 part_type type_ = part_type::invalid;
112 152
113 }; 153 };
114 154
diff --git a/lib/query.h b/lib/query.h index 214bf99..75651f6 100644 --- a/lib/query.h +++ b/lib/query.h
@@ -9,6 +9,7 @@
9#include <iostream> 9#include <iostream>
10#include "statement.h" 10#include "statement.h"
11#include "binding.h" 11#include "binding.h"
12#include "order.h"
12 13
13namespace verbly { 14namespace verbly {
14 15
@@ -24,11 +25,17 @@ namespace verbly {
24 class query { 25 class query {
25 public: 26 public:
26 27
27 query(const database& db, sqlite3* ppdb, filter queryFilter, bool random, int limit) : db_(&db) 28 query(const database& db, sqlite3* ppdb, filter queryFilter, order sortOrder, int limit) : db_(&db)
28 { 29 {
30 if ((sortOrder.getType() == order::type::field)
31 && (sortOrder.getSortField().getObject() != Object::objectType))
32 {
33 throw std::invalid_argument("Can only sort query by a field in the result table");
34 }
35
29 statement stmt(Object::objectType, std::move(queryFilter)); 36 statement stmt(Object::objectType, std::move(queryFilter));
30 37
31 std::string queryString = stmt.getQueryString(Object::select, random, limit); 38 std::string queryString = stmt.getQueryString(Object::select, std::move(sortOrder), limit);
32 std::list<binding> bindings = stmt.getBindings(); 39 std::list<binding> bindings = stmt.getBindings();
33 40
34 if (sqlite3_prepare_v2(ppdb, queryString.c_str(), queryString.length(), &ppstmt_, NULL) != SQLITE_OK) 41 if (sqlite3_prepare_v2(ppdb, queryString.c_str(), queryString.length(), &ppstmt_, NULL) != SQLITE_OK)
diff --git a/lib/statement.cpp b/lib/statement.cpp index 846b9de..1512aa5 100644 --- a/lib/statement.cpp +++ b/lib/statement.cpp
@@ -5,11 +5,12 @@
5#include "util.h" 5#include "util.h"
6#include "notion.h" 6#include "notion.h"
7#include "word.h" 7#include "word.h"
8#include "group.h"
9#include "frame.h" 8#include "frame.h"
9#include "part.h"
10#include "lemma.h" 10#include "lemma.h"
11#include "form.h" 11#include "form.h"
12#include "pronunciation.h" 12#include "pronunciation.h"
13#include "order.h"
13 14
14namespace verbly { 15namespace verbly {
15 16
@@ -20,7 +21,7 @@ namespace verbly {
20 { 21 {
21 } 22 }
22 23
23 std::string statement::getQueryString(std::list<std::string> select, bool random, int limit) const 24 std::string statement::getQueryString(std::list<std::string> select, order sortOrder, int limit, bool debug) const
24 { 25 {
25 std::stringstream queryStream; 26 std::stringstream queryStream;
26 27
@@ -49,7 +50,7 @@ namespace verbly {
49 if (cte.getCondition().getType() != condition::type::empty) 50 if (cte.getCondition().getType() != condition::type::empty)
50 { 51 {
51 cteStream << " WHERE "; 52 cteStream << " WHERE ";
52 cteStream << cte.getCondition().toSql(); 53 cteStream << cte.getCondition().flatten().toSql(true, debug);
53 } 54 }
54 55
55 if (cte.isRecursive()) 56 if (cte.isRecursive())
@@ -101,12 +102,28 @@ namespace verbly {
101 if (topCondition_.getType() != condition::type::empty) 102 if (topCondition_.getType() != condition::type::empty)
102 { 103 {
103 queryStream << " WHERE "; 104 queryStream << " WHERE ";
104 queryStream << topCondition_.toSql(); 105 queryStream << topCondition_.flatten().toSql(true, debug);
105 } 106 }
106 107
107 if (random) 108 queryStream << " ORDER BY ";
109
110 switch (sortOrder.getType())
108 { 111 {
109 queryStream << " ORDER BY RANDOM()"; 112 case order::type::random:
113 {
114 queryStream << "RANDOM()";
115
116 break;
117 }
118
119 case order::type::field:
120 {
121 queryStream << topTable_;
122 queryStream << ".";
123 queryStream << sortOrder.getSortField().getColumn();
124
125 break;
126 }
110 } 127 }
111 128
112 if (limit > 0) 129 if (limit > 0)
@@ -260,6 +277,7 @@ namespace verbly {
260 } 277 }
261 278
262 case field::type::join: 279 case field::type::join:
280 case field::type::join_where:
263 { 281 {
264 // First, figure out what table we need to join against. 282 // First, figure out what table we need to join against.
265 std::string joinTableName; 283 std::string joinTableName;
@@ -269,13 +287,22 @@ namespace verbly {
269 } else { 287 } else {
270 joinTableName = getTableForContext(clause.getField().getJoinObject()); 288 joinTableName = getTableForContext(clause.getField().getJoinObject());
271 } 289 }
290
291 filter joinCondition = clause.getJoinCondition();
292
293 // If this is a condition join, we need to add the field join
294 // condition to the clause.
295 if (clause.getField().getType() == field::type::join_where)
296 {
297 joinCondition &= (clause.getField().getConditionField() == clause.getField().getConditionValue());
298 }
272 299
273 // Recursively parse the subquery, and therefore obtain an 300 // Recursively parse the subquery, and therefore obtain an
274 // instantiated table to join against, as well as any joins or CTEs 301 // instantiated table to join against, as well as any joins or CTEs
275 // that the subquery may require to function. 302 // that the subquery may require to function.
276 statement joinStmt( 303 statement joinStmt(
277 joinTableName, 304 joinTableName,
278 clause.getJoinCondition().normalize(clause.getField().getJoinObject()), 305 std::move(joinCondition).normalize(clause.getField().getJoinObject()),
279 nextTableId_, 306 nextTableId_,
280 nextWithId_); 307 nextWithId_);
281 308
@@ -801,7 +828,7 @@ namespace verbly {
801 new(&singleton_.value_) binding(std::move(value)); 828 new(&singleton_.value_) binding(std::move(value));
802 } 829 }
803 830
804 std::string statement::condition::toSql() const 831 std::string statement::condition::toSql(bool toplevel, bool debug) const
805 { 832 {
806 switch (type_) 833 switch (type_)
807 { 834 {
@@ -816,42 +843,92 @@ namespace verbly {
816 { 843 {
817 case comparison::equals: 844 case comparison::equals:
818 { 845 {
819 return singleton_.table_ + "." + singleton_.column_ + " = ?"; 846 if (debug)
847 {
848 if (singleton_.value_.getType() == binding::type::string)
849 {
850 return singleton_.table_ + "." + singleton_.column_ + " = \"" + singleton_.value_.getString() + "\"";
851 } else {
852 return singleton_.table_ + "." + singleton_.column_ + " = " + std::to_string(singleton_.value_.getInteger());
853 }
854 } else {
855 return singleton_.table_ + "." + singleton_.column_ + " = ?";
856 }
820 } 857 }
821 858
822 case comparison::does_not_equal: 859 case comparison::does_not_equal:
823 { 860 {
824 return singleton_.table_ + "." + singleton_.column_ + " != ?"; 861 if (debug)
862 {
863 if (singleton_.value_.getType() == binding::type::string)
864 {
865 return singleton_.table_ + "." + singleton_.column_ + " != \"" + singleton_.value_.getString() + "\"";
866 } else {
867 return singleton_.table_ + "." + singleton_.column_ + " != " + std::to_string(singleton_.value_.getInteger());
868 }
869 } else {
870 return singleton_.table_ + "." + singleton_.column_ + " != ?";
871 }
825 } 872 }
826 873
827 case comparison::is_greater_than: 874 case comparison::is_greater_than:
828 { 875 {
829 return singleton_.table_ + "." + singleton_.column_ + " > ?"; 876 if (debug)
877 {
878 return singleton_.table_ + "." + singleton_.column_ + " > " + std::to_string(singleton_.value_.getInteger());
879 } else {
880 return singleton_.table_ + "." + singleton_.column_ + " > ?";
881 }
830 } 882 }
831 883
832 case comparison::is_at_most: 884 case comparison::is_at_most:
833 { 885 {
834 return singleton_.table_ + "." + singleton_.column_ + " <= ?"; 886 if (debug)
887 {
888 return singleton_.table_ + "." + singleton_.column_ + " <= " + std::to_string(singleton_.value_.getInteger());
889 } else {
890 return singleton_.table_ + "." + singleton_.column_ + " <= ?";
891 }
835 } 892 }
836 893
837 case comparison::is_less_than: 894 case comparison::is_less_than:
838 { 895 {
839 return singleton_.table_ + "." + singleton_.column_ + " < ?"; 896 if (debug)
897 {
898 return singleton_.table_ + "." + singleton_.column_ + " < " + std::to_string(singleton_.value_.getInteger());
899 } else {
900 return singleton_.table_ + "." + singleton_.column_ + " < ?";
901 }
840 } 902 }
841 903
842 case comparison::is_at_least: 904 case comparison::is_at_least:
843 { 905 {
844 return singleton_.table_ + "." + singleton_.column_ + " >= ?"; 906 if (debug)
907 {
908 return singleton_.table_ + "." + singleton_.column_ + " >= " + std::to_string(singleton_.value_.getInteger());
909 } else {
910 return singleton_.table_ + "." + singleton_.column_ + " >= ?";
911 }
845 } 912 }
846 913
847 case comparison::is_like: 914 case comparison::is_like:
848 { 915 {
849 return singleton_.table_ + "." + singleton_.column_ + " LIKE ?"; 916 if (debug)
917 {
918 return singleton_.table_ + "." + singleton_.column_ + " LIKE \"" + singleton_.value_.getString() + "\"";
919 } else {
920 return singleton_.table_ + "." + singleton_.column_ + " LIKE ?";
921 }
850 } 922 }
851 923
852 case comparison::is_not_like: 924 case comparison::is_not_like:
853 { 925 {
854 return singleton_.table_ + "." + singleton_.column_ + " NOT LIKE ?"; 926 if (debug)
927 {
928 return singleton_.table_ + "." + singleton_.column_ + " NOT LIKE \"" + singleton_.value_.getString() + "\"";
929 } else {
930 return singleton_.table_ + "." + singleton_.column_ + " NOT LIKE ?";
931 }
855 } 932 }
856 933
857 case comparison::is_not_null: 934 case comparison::is_not_null:
@@ -871,10 +948,25 @@ namespace verbly {
871 std::list<std::string> clauses; 948 std::list<std::string> clauses;
872 for (const condition& cond : group_.children_) 949 for (const condition& cond : group_.children_)
873 { 950 {
874 clauses.push_back(cond.toSql()); 951 clauses.push_back(cond.toSql(false, debug));
875 } 952 }
876 953
877 return implode(std::begin(clauses), std::end(clauses), group_.orlogic_ ? " OR " : " AND "); 954 if (clauses.empty())
955 {
956 return "";
957 } else if (clauses.size() == 1)
958 {
959 return clauses.front();
960 } else {
961 std::string result = implode(std::begin(clauses), std::end(clauses), group_.orlogic_ ? " OR " : " AND ");
962
963 if (toplevel)
964 {
965 return result;
966 } else {
967 return "(" + result + ")";
968 }
969 }
878 } 970 }
879 } 971 }
880 } 972 }
@@ -988,5 +1080,39 @@ namespace verbly {
988 throw std::domain_error("Cannot get children of non-group condition"); 1080 throw std::domain_error("Cannot get children of non-group condition");
989 } 1081 }
990 } 1082 }
1083
1084 statement::condition statement::condition::flatten() const
1085 {
1086 switch (type_)
1087 {
1088 case type::empty:
1089 case type::singleton:
1090 {
1091 return *this;
1092 }
1093
1094 case type::group:
1095 {
1096 condition result(group_.orlogic_);
1097
1098 for (const condition& child : group_.children_)
1099 {
1100 condition newChild = child.flatten();
1101
1102 if ((newChild.type_ == type::group) && (newChild.group_.orlogic_ == group_.orlogic_))
1103 {
1104 for (condition subChild : std::move(newChild.group_.children_))
1105 {
1106 result += std::move(subChild);
1107 }
1108 } else {
1109 result += std::move(newChild);
1110 }
1111 }
1112
1113 return result;
1114 }
1115 }
1116 }
991 1117
992}; 1118};
diff --git a/lib/statement.h b/lib/statement.h index aa56568..15c4ac3 100644 --- a/lib/statement.h +++ b/lib/statement.h
@@ -13,13 +13,14 @@
13namespace verbly { 13namespace verbly {
14 14
15 class filter; 15 class filter;
16 class order;
16 17
17 class statement { 18 class statement {
18 public: 19 public:
19 20
20 statement(object context, filter queryFilter); 21 statement(object context, filter queryFilter);
21 22
22 std::string getQueryString(std::list<std::string> select, bool random, int limit) const; 23 std::string getQueryString(std::list<std::string> select, order sortOrder, int limit, bool debug = false) const;
23 24
24 std::list<binding> getBindings() const; 25 std::list<binding> getBindings() const;
25 26
@@ -153,10 +154,12 @@ namespace verbly {
153 154
154 // Utility 155 // Utility
155 156
156 std::string toSql() const; 157 std::string toSql(bool toplevel, bool debug = false) const;
157 158
158 std::list<binding> flattenBindings() const; 159 std::list<binding> flattenBindings() const;
159 160
161 condition flatten() const;
162
160 private: 163 private:
161 union { 164 union {
162 struct { 165 struct {
@@ -246,8 +249,8 @@ namespace verbly {
246 { 249 {
247 return (context == object::notion) ? "notions" 250 return (context == object::notion) ? "notions"
248 : (context == object::word) ? "words" 251 : (context == object::word) ? "words"
249 : (context == object::group) ? "groups"
250 : (context == object::frame) ? "frames" 252 : (context == object::frame) ? "frames"
253 : (context == object::part) ? "parts"
251 : (context == object::lemma) ? "lemmas_forms" 254 : (context == object::lemma) ? "lemmas_forms"
252 : (context == object::form) ? "forms" 255 : (context == object::form) ? "forms"
253 : (context == object::pronunciation) ? "pronunciations" 256 : (context == object::pronunciation) ? "pronunciations"
diff --git a/lib/verbly.h b/lib/verbly.h index d8875b3..112907b 100644 --- a/lib/verbly.h +++ b/lib/verbly.h
@@ -6,16 +6,15 @@
6#include "filter.h" 6#include "filter.h"
7#include "field.h" 7#include "field.h"
8#include "query.h" 8#include "query.h"
9#include "order.h"
9#include "notion.h" 10#include "notion.h"
10#include "word.h" 11#include "word.h"
11#include "group.h"
12#include "frame.h" 12#include "frame.h"
13#include "part.h"
13#include "lemma.h" 14#include "lemma.h"
14#include "form.h" 15#include "form.h"
15#include "pronunciation.h" 16#include "pronunciation.h"
16#include "token.h" 17#include "token.h"
17#include "selrestr.h" 18#include "selrestr.h"
18#include "part.h"
19#include "role.h"
20 19
21#endif /* end of include guard: VERBLY_H_5B39CE50 */ 20#endif /* end of include guard: VERBLY_H_5B39CE50 */
diff --git a/lib/word.cpp b/lib/word.cpp index a928659..90eab1d 100644 --- a/lib/word.cpp +++ b/lib/word.cpp
@@ -17,7 +17,7 @@ namespace verbly {
17 17
18 const field word::notion = field::joinField(object::word, "notion_id", object::notion); 18 const field word::notion = field::joinField(object::word, "notion_id", object::notion);
19 const field word::lemma = field::joinField(object::word, "lemma_id", object::lemma); 19 const field word::lemma = field::joinField(object::word, "lemma_id", object::lemma);
20 const field word::group = field::joinField(object::word, "group_id", object::group, true); 20 const field word::frame = field::joinField(object::word, "group_id", object::frame, true);
21 21
22 const field word::antonyms = field::selfJoin(object::word, "word_id", "antonymy", "antonym_2_id", "antonym_1_id"); 22 const field word::antonyms = field::selfJoin(object::word, "word_id", "antonymy", "antonym_2_id", "antonym_1_id");
23 23
@@ -93,7 +93,27 @@ namespace verbly {
93 return lemma_; 93 return lemma_;
94 } 94 }
95 95
96 const group& word::getGroup() const 96 bool word::hasFrames() const
97 {
98 if (!valid_)
99 {
100 throw std::domain_error("Bad access to uninitialized word");
101 }
102
103 if (!hasGroup_)
104 {
105 return false;
106 }
107
108 if (!initializedFrames_)
109 {
110 initializeFrames();
111 }
112
113 return !frames_.empty();
114 }
115
116 const std::vector<frame>& word::getFrames() const
97 { 117 {
98 if (!valid_) 118 if (!valid_)
99 { 119 {
@@ -105,12 +125,12 @@ namespace verbly {
105 throw std::domain_error("Word does not have a group"); 125 throw std::domain_error("Word does not have a group");
106 } 126 }
107 127
108 if (!group_) 128 if (!initializedFrames_)
109 { 129 {
110 group_ = db_->groups(group::id == groupId_).first(); 130 initializeFrames();
111 } 131 }
112 132
113 return group_; 133 return frames_;
114 } 134 }
115 135
116 std::string word::getBaseForm() const 136 std::string word::getBaseForm() const
@@ -129,4 +149,10 @@ namespace verbly {
129 return result; 149 return result;
130 } 150 }
131 151
152 void word::initializeFrames() const
153 {
154 initializedFrames_ = true;
155 frames_ = db_->frames(*this, {}, -1).all();
156 }
157
132}; 158};
diff --git a/lib/word.h b/lib/word.h index ddcabe4..8a333a4 100644 --- a/lib/word.h +++ b/lib/word.h
@@ -7,7 +7,7 @@
7#include "filter.h" 7#include "filter.h"
8#include "notion.h" 8#include "notion.h"
9#include "lemma.h" 9#include "lemma.h"
10#include "group.h" 10#include "frame.h"
11 11
12struct sqlite3_stmt; 12struct sqlite3_stmt;
13 13
@@ -97,17 +97,9 @@ namespace verbly {
97 97
98 const lemma& getLemma() const; 98 const lemma& getLemma() const;
99 99
100 bool hasGroup() const 100 bool hasFrames() const;
101 {
102 if (!valid_)
103 {
104 throw std::domain_error("Bad access to uninitialized word");
105 }
106 101
107 return hasGroup_; 102 const std::vector<frame>& getFrames() const;
108 }
109
110 const group& getGroup() const;
111 103
112 // Convenience accessors 104 // Convenience accessors
113 105
@@ -136,7 +128,7 @@ namespace verbly {
136 128
137 static const field notion; 129 static const field notion;
138 static const field lemma; 130 static const field lemma;
139 static const field group; 131 static const field frame;
140 132
141 // Relationships with self 133 // Relationships with self
142 134
@@ -161,6 +153,9 @@ namespace verbly {
161 static const field regionalDomains; 153 static const field regionalDomains;
162 154
163 private: 155 private:
156
157 void initializeFrames() const;
158
164 bool valid_ = false; 159 bool valid_ = false;
165 160
166 int id_; 161 int id_;
@@ -176,7 +171,9 @@ namespace verbly {
176 171
177 mutable class notion notion_; 172 mutable class notion notion_;
178 mutable class lemma lemma_; 173 mutable class lemma lemma_;
179 mutable class group group_; 174
175 mutable bool initializedFrames_ = false;
176 mutable std::vector<class frame> frames_;
180 177
181 }; 178 };
182 179
generated by cgit-pink 1.4.1 (git 2.36.1) at 2024-06-30 23:42:44 +0000