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

#ifndef PART_H_FB54F361
#define PART_H_FB54F361

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

namespace verbly {
  namespace generator {
    
    class part {
    public:
      enum class type {
        invalid = -1,
        noun_phrase = 0,
        verb = 1,
        preposition = 2,
        adjective = 3,
        adverb = 4,
        literal = 5
      };
      
      // 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);
      
      // 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
      
      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:
      
      // Private constructors
      
      part()
      {
      }
      
      part(type t) : 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 */