generator/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

#ifndef PART_H_FB54F361
#define PART_H_FB54F361

#include <string>
#include <set>
#include "../lib/selrestr.h"
#include "../lib/enums.h"

namespace verbly {

  namespace generator {

    class part {
    public:

      using type = part_type;

      // Static factories

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

      static part createVerb();

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

      static part createAdjective();

      static part createAdverb();

      static part createLiteral(std::string value);

      // Duplication

      static part duplicate(const part& other);

      // 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

      int getId() const
      {
        return id_;
      }

      type getType() const
      {
        return type_;
      }

      // Noun phrase accessors

      std::string getNounRole() const;

      selrestr getNounSelrestrs() const;

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

      // Preposition accessors

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

      bool isPrepositionLiteral() const;

      // Literal accessors

      std::string getLiteralValue() const;

    private:

      static int nextId_;

      int id_;

      // Private constructors

      part()
      {
      }

      part(type t) :
        id_(nextId_++),
        type_(t)
      {
      }

      // Data

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

      type type_ = type::invalid;

    };

  };
};

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