← Back to branch summary

~ubuntu-branches/ubuntu/wily/libtorrent/wily-proposed

« back to all changes in this revision

Viewing changes to src/torrent/hash_string.h

  • Committer: Bazaar Package Importer
  • Author(s): Rogério Brito
  • Date: 2011-03-20 01:06:18 UTC
  • mfrom: (1.1.13 upstream) (4.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110320010618-g3wyylccqzqko73c
Tags: 0.12.7-5
http://bugs.debian.org/617791
* Use Steinar's "real" patch for IPv6. Addresses #490277, #618275,
  and Closes: #617791.
* Adapt libtorrent-0.12.6-ipv6-07.patch. It FTBFS otherwise.
* Add proper attibution to the IPv6 patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/torrent/hash_string.h
 
1
// libTorrent - BitTorrent library
 
2
// Copyright (C) 2005-2007, Jari Sundell
 
3
//
 
4
// This program is free software; you can redistribute it and/or modify
 
5
// it under the terms of the GNU General Public License as published by
 
6
// the Free Software Foundation; either version 2 of the License, or
 
7
// (at your option) any later version.
 
8
// 
 
9
// This program is distributed in the hope that it will be useful,
 
10
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
// GNU General Public License for more details.
 
13
// 
 
14
// You should have received a copy of the GNU General Public License
 
15
// along with this program; if not, write to the Free Software
 
16
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
//
 
18
// In addition, as a special exception, the copyright holders give
 
19
// permission to link the code of portions of this program with the
 
20
// OpenSSL library under certain conditions as described in each
 
21
// individual source file, and distribute linked combinations
 
22
// including the two.
 
23
//
 
24
// You must obey the GNU General Public License in all respects for
 
25
// all of the code used other than OpenSSL.  If you modify file(s)
 
26
// with this exception, you may extend this exception to your version
 
27
// of the file(s), but you are not obligated to do so.  If you do not
 
28
// wish to do so, delete this exception statement from your version.
 
29
// If you delete this exception statement from all source files in the
 
30
// program, then also delete it here.
 
31
//
 
32
// Contact:  Jari Sundell <jaris@ifi.uio.no>
 
33
//
 
34
//           Skomakerveien 33
 
35
//           3185 Skoppum, NORWAY
 
36
 
 
37
// A fixed with char array used to store 20 byte with hashes. This
 
38
// should really be replaced with std::array<20>.
 
39
 
 
40
#ifndef LIBTORRENT_HASH_STRING_H
 
41
#define LIBTORRENT_HASH_STRING_H
 
42
 
 
43
#include <cstring>
 
44
#include <string>
 
45
#include <iterator>
 
46
#include <torrent/common.h>
 
47
 
 
48
namespace torrent {
 
49
 
 
50
class LIBTORRENT_EXPORT HashString {
 
51
public:
 
52
  typedef char                                    value_type;
 
53
  typedef value_type&                             reference;
 
54
  typedef const value_type&                       const_reference;
 
55
  typedef value_type*                             iterator;
 
56
  typedef const value_type*                       const_iterator;
 
57
  typedef std::size_t                             size_type;
 
58
  typedef std::ptrdiff_t                          difference_type;
 
59
  typedef std::reverse_iterator<iterator>         reverse_iterator;
 
60
  typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
 
61
 
 
62
  static const size_type size_data = 20;
 
63
 
 
64
  size_type           size() const                      { return size_data; }
 
65
 
 
66
  iterator            begin()                           { return m_data; }
 
67
  const_iterator      begin() const                     { return m_data; }
 
68
 
 
69
  iterator            end()                             { return m_data + size(); }
 
70
  const_iterator      end() const                       { return m_data + size(); }
 
71
 
 
72
  reverse_iterator       rbegin()                       { return reverse_iterator(end()); }
 
73
  const_reverse_iterator rbegin() const                 { return const_reverse_iterator(end()); }
 
74
 
 
75
  reverse_iterator       rend()                         { return reverse_iterator(begin()); }
 
76
  const_reverse_iterator rend() const                   { return const_reverse_iterator(begin()); }
 
77
 
 
78
  reference           operator [] (size_type n)         { return *(m_data + n); }
 
79
  const_reference     operator [] (size_type n) const   { return *(m_data + n); }
 
80
 
 
81
  value_type*         data()                            { return m_data; }
 
82
  const value_type*   data() const                      { return m_data; }
 
83
 
 
84
  const value_type*   c_str() const                     { return m_data; }
 
85
 
 
86
  std::string         str() const                       { return std::string(m_data, size_data); }
 
87
 
 
88
  void                clear(int v = 0)                  { std::memset(data(), v, size()); }
 
89
 
 
90
  void                assign(const value_type* src)     { std::memcpy(data(), src, size()); }
 
91
 
 
92
  bool                equal_to(const char* hash) const     { return std::memcmp(m_data, hash, size()) == 0; }
 
93
  bool                not_equal_to(const char* hash) const { return std::memcmp(m_data, hash, size()) != 0; }
 
94
 
 
95
  // It is the users responsibility to ensure src.length() >=
 
96
  // size_data.
 
97
  static const HashString* cast_from(const char* src)        { return (const HashString*)src; }
 
98
  static const HashString* cast_from(const std::string& src) { return (const HashString*)src.c_str(); }
 
99
 
 
100
  static HashString*  cast_from(char* src)                   { return (HashString*)src; }
 
101
 
 
102
private:
 
103
  char                m_data[size_data];
 
104
};
 
105
 
 
106
const char* hash_string_from_hex_c_str(const char* first, HashString& hash) LIBTORRENT_EXPORT;
 
107
  
 
108
inline bool
 
109
operator == (const HashString& one, const HashString& two) {
 
110
  return std::memcmp(one.begin(), two.begin(), HashString::size_data) == 0;
 
111
}
 
112
 
 
113
inline bool
 
114
operator != (const HashString& one, const HashString& two) {
 
115
  return std::memcmp(one.begin(), two.begin(), HashString::size_data) != 0;
 
116
}
 
117
 
 
118
inline bool
 
119
operator < (const HashString& one, const HashString& two) {
 
120
  return std::memcmp(one.begin(), two.begin(), HashString::size_data) < 0;
 
121
}
 
122
 
 
123
inline bool
 
124
operator <= (const HashString& one, const HashString& two) {
 
125
  return std::memcmp(one.begin(), two.begin(), HashString::size_data) <= 0;
 
126
}
 
127
 
 
128
}
 
129
 
 
130
#endif