lib/form.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

#ifndef FORM_H_3A6C962C
#define FORM_H_3A6C962C

#include <list>
#include <vector>
#include <string>
#include <stdexcept>
#include "field.h"
#include "pronunciation.h"
#include "filter.h"

struct sqlite3_stmt;

namespace verbly {

  class database;

  class form {
  public:

    // Default constructor

    form() = default;

    // Construct from database

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

    // Accessors

    operator bool() const
    {
      return valid_;
    }

    int getId() const
    {
      if (!valid_)
      {
        throw std::domain_error("Bad access to uninitialized form");
      }

      return id_;
    }

    std::string getText() const
    {
      if (!valid_)
      {
        throw std::domain_error("Bad access to uninitialized form");
      }

      return text_;
    }

    int getComplexity() const
    {
      if (!valid_)
      {
        throw std::domain_error("Bad access to uninitialized form");
      }

      return complexity_;
    }

    bool isProper() const
    {
      if (!valid_)
      {
        throw std::domain_error("Bad access to uninitialized form");
      }

      return proper_;
    }

    const std::vector<pronunciation>& getPronunciations() const;

    // Convenience

    bool startsWithVowelSound() const;

    // Type info

    static const object objectType;

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

    // Query fields

    static const field id;
    static const field text;
    static const field complexity;
    static const field proper;

    operator filter() const
    {
      if (!valid_)
      {
        throw std::domain_error("Bad access to uninitialized form");
      }

      return (id == id_);
    }

    // Relationships to other objects

    static const field pronunciation;

    class inflection_field {
    public:

      inflection_field(inflection category) : category_(category)
      {
      }

      const inflection getCategory() const
      {
        return category_;
      }
      
    private:

      const inflection category_;
    };

    static const inflection_field lemma(inflection category)
    {
      return inflection_field(category);
    }

    friend filter operator%=(form::inflection_field check, filter joinCondition);

  private:
    bool valid_ = false;

    int id_;
    std::string text_;
    int complexity_ ;
    bool proper_;

    const database* db_;

    mutable bool initializedPronunciations_ = false;
    mutable std::vector<class pronunciation> pronunciations_;

    static const field lemmaJoin;
    static const field inflectionCategory;

  };

};

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