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
|
// file : inheritance/reuse/employee.hxx
// copyright : not copyrighted - public domain
#ifndef EMPLOYEE_HXX
#define EMPLOYEE_HXX
#include <string>
#include <odb/core.hxx>
// Abstract person class. Note that it does not declare the object id.
//
#pragma db object abstract
class person
{
public:
person (const std::string& first, const std::string& last)
: first_ (first), last_ (last)
{
}
const std::string&
first () const
{
return first_;
}
const std::string&
last () const
{
return last_;
}
protected:
friend class odb::access;
person () {}
private:
std::string first_;
std::string last_;
};
// Abstract employee class. It derives from the person class and declares
// the object id for all the concrete employee types.
//
#pragma db object abstract
class employee: public person
{
public:
employee (const std::string& first, const std::string& last)
: person (first, last)
{
}
unsigned long
number () const
{
return id_;
}
protected:
friend class odb::access;
employee () {}
private:
#pragma db id auto
unsigned long id_;
};
// Concrete permanent_employee class. Note that it doesn't define any
// data members of its own.
//
#pragma db object
class permanent_employee: public employee
{
public:
permanent_employee (const std::string& first, const std::string& last)
: employee (first, last)
{
}
private:
friend class odb::access;
permanent_employee () {}
};
// Concrete temporary_employee class. It adds the employment duration in
// months.
//
#pragma db object
class temporary_employee: public employee
{
public:
temporary_employee (const std::string& first,
const std::string& last,
unsigned long duration)
: employee (first, last), duration_ (duration)
{
}
unsigned long
duration () const
{
return duration_;
}
private:
friend class odb::access;
temporary_employee () {}
unsigned long duration_;
};
// Concrete contractor class. It derives from the person class (and not
// employee; an independent contractor is not considered an employee).
// We use the contractor's external email address as the object id.
//
#pragma db object
class contractor: public person
{
public:
contractor (const std::string& first,
const std::string& last,
const std::string& email)
: person (first, last), email_ (email)
{
}
const std::string&
email () const
{
return email_;
}
private:
friend class odb::access;
contractor () {}
#pragma db id
std::string email_;
};
#endif // EMPLOYEE_HXX
|
