← Back to branch summary

~ubuntu-branches/debian/experimental/libtorrent/experimental

« back to all changes in this revision

Viewing changes to rak/string_manip.h

  • Committer: Bazaar Package Importer
  • Author(s): Qingning Huo
  • Date: 2006-01-12 20:47:33 UTC
  • mto: (4.1.1 edgy) (6.2.1 squeeze) (1.3.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20060112204733-2vw5t3vdne40s8mq
Tags: upstream-0.8.2
Import upstream version 0.8.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
rak/string_manip.h
37
37
#ifndef RAK_STRING_MANIP_H
38
38
#define RAK_STRING_MANIP_H
39
39
 
 
40
#include <algorithm>
40
41
#include <cctype>
 
42
#include <cstdlib>
 
43
#include <iterator>
 
44
#include <locale>
41
45
 
42
46
namespace rak {
43
47
 
74
78
  return trim_begin(trim_end(seq));
75
79
}
76
80
 
 
81
// Consider rewritting such that m_seq is replaced by first/last.
 
82
template <typename Sequence>
 
83
class split_iterator_t {
 
84
public:
 
85
  typedef typename Sequence::const_iterator const_iterator;
 
86
  typedef typename Sequence::value_type     value_type;
 
87
 
 
88
  split_iterator_t() {}
 
89
 
 
90
  split_iterator_t(const Sequence& seq, value_type delim) :
 
91
    m_seq(&seq),
 
92
    m_delim(delim),
 
93
    m_pos(seq.begin()),
 
94
    m_next(std::find(seq.begin(), seq.end(), delim)) {
 
95
  }
 
96
 
 
97
  Sequence operator * () { return Sequence(m_pos, m_next); }
 
98
 
 
99
  split_iterator_t& operator ++ () {
 
100
    m_pos = m_next;
 
101
 
 
102
    if (m_pos == m_seq->end())
 
103
      return *this;
 
104
 
 
105
    m_pos++;
 
106
    m_next = std::find(m_pos, m_seq->end(), m_delim);
 
107
 
 
108
    return *this;
 
109
  }
 
110
 
 
111
  bool operator == (const split_iterator_t& itr) const { return m_pos == m_seq->end(); }
 
112
  bool operator != (const split_iterator_t& itr) const { return m_pos != m_seq->end(); }
 
113
 
 
114
private:
 
115
  const Sequence* m_seq;
 
116
  value_type      m_delim;
 
117
  const_iterator  m_pos;
 
118
  const_iterator  m_next;
 
119
};
 
120
 
 
121
template <typename Sequence>
 
122
inline split_iterator_t<Sequence>
 
123
split_iterator(const Sequence& seq, typename Sequence::value_type delim) {
 
124
  return split_iterator_t<Sequence>(seq, delim);
 
125
}
 
126
 
 
127
template <typename Sequence>
 
128
inline split_iterator_t<Sequence>
 
129
split_iterator(const Sequence& seq) {
 
130
  return split_iterator_t<Sequence>();
 
131
}
 
132
 
 
133
template <int pos, typename Value>
 
134
inline char
 
135
value_to_hexchar(Value v) {
 
136
  v >>= pos * 4;
 
137
  v &= 0xf;
 
138
 
 
139
  if (v < 0xA)
 
140
    return '0' + v;
 
141
  else
 
142
    return 'A' + v - 0xA;
 
143
}
 
144
 
 
145
template <typename InputIterator, typename OutputIterator> 
 
146
OutputIterator
 
147
copy_escape_html(InputIterator first, InputIterator last, OutputIterator dest) {
 
148
  while (first != last) {
 
149
    if (std::isalpha(*first) ||
 
150
        std::isdigit(*first) ||
 
151
        *first == '-') {
 
152
      *(dest++) = *first;
 
153
 
 
154
    } else {
 
155
      *(dest++) = '%';
 
156
      *(dest++) = value_to_hexchar<1>(*first);
 
157
      *(dest++) = value_to_hexchar<0>(*first);
 
158
    }
 
159
 
 
160
    ++first;
 
161
  }
 
162
 
 
163
  return dest;
 
164
}
 
165
 
 
166
template <typename Sequence>
 
167
Sequence
 
168
copy_escape_html(const Sequence& src) {
 
169
  Sequence dest;
 
170
  copy_escape_html(src.begin(), src.end(), std::back_inserter(dest));
 
171
 
 
172
  return dest;
 
173
}
 
174
 
 
175
// Consider support for larger than char type.
 
176
template <typename InputIterator, typename OutputIterator> 
 
177
OutputIterator
 
178
transform_hex(InputIterator first, InputIterator last, OutputIterator dest) {
 
179
  while (first != last) {
 
180
    *(dest++) = value_to_hexchar<1>(*first);
 
181
    *(dest++) = value_to_hexchar<0>(*first);
 
182
 
 
183
    ++first;
 
184
  }
 
185
 
 
186
  return dest;
 
187
}
 
188
 
 
189
template <typename Sequence>
 
190
Sequence
 
191
transform_hex(const Sequence& src) {
 
192
  Sequence dest;
 
193
  transform_hex(src.begin(), src.end(), std::back_inserter(dest));
 
194
 
 
195
  return dest;
 
196
}
 
197
 
 
198
template <typename Sequence>
 
199
Sequence
 
200
generate_random(size_t length) {
 
201
  Sequence s;
 
202
  s.reserve(length);
 
203
 
 
204
  std::generate_n(std::back_inserter(s), length, &std::rand);
 
205
 
 
206
  return s;
 
207
}
 
208
 
77
209
}
78
210
 
79
211
#endif