lib/part.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

#ifndef PART_H_C8F0661B
#define PART_H_C8F0661B

#include <string>
#include <vector>
#include <set>
#include <list>
#include "field.h"
#include "filter.h"
#include "enums.h"

struct sqlite3_stmt;

namespace verbly {

  class database;

  class part {
  public:

    // Static factories

    static part createNounPhrase(std::string role, std::set<std::string> selrestrs, std::set<std::string> synrestrs);

    static part createVerb();

    static part createPreposition(std::vector<std::string> choices, bool literal);

    static part createAdjective();

    static part createAdverb();

    static part createLiteral(std::string value);

    // Default constructor

    part()
    {
    }

    // Construct from database

    part(const database& db, sqlite3_stmt* row);

    // Copy and move constructors

    part(const part& other);

    part(part&& other);

    // Assignment

    part& operator=(part other);

    // Swap

    friend void swap(part& first, part& second);

    // Destructor

    ~part();

    // General accessors

    bool isValid() const
    {
      return (type_ != part_type::invalid);
    }

    part_type getType() const
    {
      return type_;
    }

    // Noun phrase accessors

    std::string getNounRole() const;

    std::set<std::string> getNounSelrestrs() const;

    std::set<std::string> getNounSynrestrs() const;

    bool nounHasSynrestr(std::string synrestr) const;

    // Preposition accessors

    std::vector<std::string> getPrepositionChoices() const;

    bool isPrepositionLiteral() const;

    // Literal accessors

    std::string getLiteralValue() const;

    // Type info

    static const object objectType;

    static const std::list<std::string> select;

    // Query fields

    static const field index;
    static const field type;

    static const field role;

    // Relationships to other objects

    static const field frames;

    // Noun selrestr and synrestr relationships

    class selrestr_field {
    public:

      filter operator%=(std::string selrestr) const;

    private:

      static const field selrestrJoin;
      static const field selrestrField;
    };

    static const selrestr_field selrestrs;
    
    class synrestr_field {
    public:

      filter operator%=(std::string synrestr) const;

    private:

      static const field synrestrJoin;
      static const field synrestrField;
    };

    static const synrestr_field synrestrs;

  private:

    // Private constructors

    part(part_type t) : type_(t)
    {
    }

    // Data

    union {
      struct {
        std::string role;
        std::set<std::string> selrestrs;
        std::set<std::string> synrestrs;
      } noun_phrase_;
      struct {
        std::vector<std::string> choices;
        bool literal;
      } preposition_;
      std::string literal_;
    };

    part_type type_ = part_type::invalid;

  };

};

#endif /* end of include guard: PART_H_C8F0661B */