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

#ifndef PART_H_C8F0661B
#define PART_H_C8F0661B

#include <string>
#include <vector>
#include <set>
#include <list>
#include <hkutil/database.h>
#include <variant>
#include "field.h"
#include "filter.h"
#include "enums.h"

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);

    // Construct from database

    part(const database& db, hatkirby::row row);

    // General accessors

    part_type getType() const
    {
      return type_;
    }

    // Noun phrase accessors

    const std::string& getNounRole() const;

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

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

    bool nounHasSynrestr(std::string synrestr) const;

    // Preposition accessors

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

    bool isPrepositionLiteral() const;

    // Literal accessors

    const 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:

    // Data

    struct np_type {
      std::string role;
      std::set<std::string> selrestrs;
      std::set<std::string> synrestrs;
    };

    struct prep_type {
      std::vector<std::string> choices;
      bool literal;
    };

    using variant_type =
      std::variant<
        std::monostate,
        np_type,
        prep_type,
        std::string>;

    variant_type variant_;

    part_type type_ = part_type::invalid;

    // Private constructors

    part(part_type t, variant_type v = {}) : type_(t), variant_(v)
    {
    }

  };

};

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