blob: b28d7a0b0e786408affb5c6077681a5a05ff910d (
plain)
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
|
// file : common/wrapper/test.hxx
// author : Boris Kolpackov <boris@codesynthesis.com>
// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file
#ifndef TEST_HXX
#define TEST_HXX
#include <common/config.hxx> // HAVE_TR1_MEMORY
#include <string>
#include <memory> // std::auto_ptr
#include <vector>
#include <odb/core.hxx>
#include <odb/nullable.hxx>
#ifdef HAVE_TR1_MEMORY
# include <odb/tr1/memory.hxx>
#endif
using odb::nullable;
//
// Simple values.
//
typedef nullable<std::string> nullable_string;
#ifdef HAVE_TR1_MEMORY
typedef std::tr1::shared_ptr<std::string> tr1_nullable_string;
#endif
#pragma db object
struct object
{
#pragma db id auto
unsigned long id_;
std::auto_ptr<int> num;
#pragma db null
std::auto_ptr<std::string> str;
nullable_string nstr;
std::vector<nullable_string> nstrs;
#ifdef HAVE_TR1_MEMORY
#pragma db null
tr1_nullable_string tr1_str;
#pragma db value_null
std::vector<tr1_nullable_string> tr1_strs;
#endif
};
//
// Composite values.
//
#pragma db value
struct comp1
{
comp1 () {}
comp1 (const std::string& s, int n): str (s), num (n) {}
std::string str;
int num;
};
inline bool
operator== (const comp1& x, const comp1 y)
{
return x.str == y.str && x.num == y.num;
}
#pragma db value
struct comp2
{
comp2 () {}
comp2 (const std::string& s, int n): str (s), num (n) {}
std::string str;
int num;
std::vector<std::string> strs;
};
inline bool
operator== (const comp2& x, const comp2 y)
{
return x.str == y.str && x.num == y.num && x.strs == y.strs;
}
#pragma db object
struct comp_object
{
#pragma db id auto
unsigned long id_;
std::auto_ptr<comp1> c1; // Wrapped comp value.
std::vector<nullable<comp1> > vc1; // Container of wrapped comp values.
std::auto_ptr<comp2> c2; // Container inside wrapped comp value.
};
// This one is just a compilation test to cover more convolute cases.
//
#pragma db value
struct comp3: comp2
{
std::auto_ptr<comp1> c1;
std::vector<nullable<comp1> > vc1;
};
#pragma db object
struct comp_object2
{
#pragma db id auto
unsigned long id_;
std::auto_ptr<comp3> c3;
};
#endif // TEST_HXX
|
