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
|
// file : xsde/cxx/string-sequence-stl.cxx
// author : Boris Kolpackov <boris@codesynthesis.com>
// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC
// license : GNU GPL v2 + exceptions; see accompanying LICENSE file
#include <xsde/cxx/string-sequence-stl.hxx>
namespace xsde
{
namespace cxx
{
void string_sequence::
clear ()
{
typedef std::string type;
for (size_t i = 0; i < size_; ++i)
static_cast<std::string*> (data_)[i].~type ();
size_ = 0;
}
#ifdef XSDE_EXCEPTIONS
struct guard
{
guard (std::string* p, size_t& n) : p_ (p), n_ (n) {}
~guard ()
{
typedef std::string type;
if (p_)
for (; n_ > 0; --n_)
p_[n_ - 1].~type ();
}
void
release () { p_ = 0; }
private:
std::string* p_;
size_t& n_;
};
void string_sequence::
move_ (void* dst, void* src, size_t n)
{
std::string* d = static_cast<std::string*> (dst);
std::string* s = static_cast<std::string*> (src);
// The copy c-tor can throw in which case we need to destroy
// whatever objects we already copied into d.
//
size_t i = 0;
guard g (d, i);
for (; i < n; i++)
new (d + i) std::string (s[i]);
g.release ();
typedef std::string type;
for (size_t j = 0; j < n; j++)
s[j].~type ();
}
#else
void string_sequence::
move_ (void* dst, void* src, size_t n)
{
std::string* d = static_cast<std::string*> (dst);
std::string* s = static_cast<std::string*> (src);
for (size_t i = 0; i < n; i++)
{
typedef std::string type;
new (d + i) std::string (s[i]);
s[i].~type ();
}
}
#endif
void string_sequence::
move_forward_ (void* p, size_t n)
{
// We are moving a sequence of elements one position to the left.
// The tricky part is to make sure we are in at least destructable
// state if things turn bad. We assume that there is a valid
// element at position p.
//
std::string* d = static_cast<std::string*> (p);
for (size_t i = 0; i < n; i++)
d[i] = d[i + 1];
typedef std::string type;
d[n].~type ();
}
#ifdef XSDE_EXCEPTIONS
void string_sequence::
move_backward_ (void* p, size_t n, size_t& size)
{
// We are moving a sequence of elements one position to the right.
// The tricky part is to make sure we are in at least destructable
// state if things turn bad.
//
std::string* d = static_cast<std::string*> (p);
std::string* e = d + n;
new (e) std::string;
size++;
for (size_t i = n; i > 0; i--)
d[i] = d[i - 1];
}
#else
void string_sequence::
move_backward_ (void* p, size_t n)
{
// We are moving a sequence of elements one position to the right.
//
std::string* d = static_cast<std::string*> (p);
std::string* e = d + n;
new (e) std::string;
for (size_t i = n; i > 0; i--)
d[i] = d[i - 1];
}
#endif
bool
operator== (const string_sequence& x, const string_sequence& y)
{
if (x.size () != y.size ())
return false;
for (string_sequence::const_iterator
xi (x.begin ()), yi (y.begin ()), xe (x.end ());
xi != xe; ++xi, ++yi)
{
if (*xi != *yi)
return false;
}
return true;
}
}
}
|
