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
|
// file : sqlite/types/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 <set>
#include <string>
#include <memory> // std::auto_ptr
#include <cstddef> // std::size_t
#include <cstring> // std::{memcmp,memcpy}
#include <odb/core.hxx>
struct buffer
{
~buffer ()
{
delete[] data_;
}
buffer ()
: data_ (0), size_ (0)
{
}
buffer (const void* data, std::size_t size)
: data_ (0), size_ (size)
{
data_ = new char[size_];
std::memcpy (data_, data, size_);
}
buffer (const buffer& y)
: data_ (0), size_ (0)
{
assign (y.data_, y.size_);
}
buffer&
operator= (const buffer& y)
{
if (this != &y)
assign (y.data_, y.size_);
return *this;
}
void
assign (const void* data, std::size_t size)
{
if (size_ < size)
{
char* p (new char[size]);
delete[] data_;
data_ = p;
}
std::memcpy (data_, data, size);
size_ = size;
}
char*
data ()
{
return data_;
}
const char*
data () const
{
return data_;
}
std::size_t
size () const
{
return size_;
}
bool
operator== (const buffer& y) const
{
return size_ == y.size_ && std::memcmp (data_, y.data_, size_) == 0;
}
private:
char* data_;
std::size_t size_;
};
typedef std::auto_ptr<std::string> string_ptr;
#pragma db object
struct object
{
object (unsigned long id)
: id_ (id)
{
}
object ()
{
}
#pragma db id
unsigned long id_;
#pragma db type ("BOOL NOT NULL")
bool bool_;
#pragma db type ("INTEGER NOT NULL")
int integer_;
#pragma db type ("REAL NOT NULL")
double real_;
#pragma db type ("TEXT NOT NULL")
std::string text_;
#pragma db type ("BLOB NOT NULL")
buffer blob_;
// Test NULL value.
//
#pragma db type ("TEXT")
string_ptr null_;
bool
operator== (const object& y) const
{
return
id_ == y.id_ &&
bool_ == y.bool_ &&
integer_ == y.integer_ &&
real_ == y.real_ &&
text_ == y.text_ &&
blob_ == y.blob_ &&
((null_.get () == 0 && y.null_.get () == 0) || *null_ == *y.null_);
}
};
#endif // TEST_HXX
|
