Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
71f75458fc44a2754d6f4c2bd3280c0a3f4bd2cd
[simgrid.git] / include / xbt / string.hpp
1 /* Copyright (c) 2015. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #ifndef SIMGRIC_XBT_STRING_HPP
8 #define SIMGRIC_XBT_STRING_HPP
9
10 #if HAVE_MC
11
12 #include <stdexcept>
13 #include <cstddef>
14 #include <cstdlib>
15 #include <cstring>
16 #include <string>
17 #include <iterator>
18
19 #include <xbt/sysdep.h>
20
21 namespace simgrid {
22 namespace xbt {
23
24 /** POD structure representation of a string
25  */
26 struct string_data {
27   char* data;
28   std::size_t len;
29 };
30
31 /** A std::string with well-known representation
32  *
33  *  This is a (incomplete) drop-in replacement for `std::string`.
34  *  It has a fixed POD representation (`simgrid::xbt::string_data`)
35  *  which can be used to easily read the string content from another
36  *  process.
37  *
38  *  The internal representation of a `std::string` is private.
39  *  We could add some code to read this for a given implementation.
40  *  However, even if we focus on GNU libstdc++ with Itanium ABI
41  *  GNU libstdc++ currently has two different ABIs
42  *
43  *  * the pre-C++11 is a pointer to a ref-counted
44  *    string-representation (with support for COW);
45  *
46  *  * the [C++11-conforming implementation](https://gcc.gnu.org/gcc-5/changes.html)
47  *    does not use refcouting/COW but has a small string optimization.
48  */
49 XBT_PUBLIC_CLASS string : private string_data {
50   static const char NUL;
51 public:
52
53   // Types
54   typedef std::size_t size_type;
55   typedef std::ptrdiff_t difference_type;
56   typedef char& reference;
57   typedef const char& const_reference;
58   typedef char* pointer;
59   typedef const char* const_pointer;
60   typedef char* iterator;
61   typedef const char* const_iterator;
62
63   // Dtor
64   ~string()
65   {
66     if (string_data::data != &NUL)
67       std::free(string_data::data);
68   }
69
70   // Ctors
71   string(const char* s, size_t size)
72   {
73     if (size == 0) {
74       string_data::len = 0;
75       string_data::data = const_cast<char*>(&NUL);
76     } else {
77       string_data::len = size;
78       string_data::data = static_cast<char*>(std::malloc(string_data::len + 1));
79       memcpy(string_data::data, s, string_data::len);
80       string_data::data[string_data::len] = '\0';
81     }
82   }
83   string() : string (nullptr, 0) {}
84   string(const char* s)
85     : string(s, s == nullptr ? 0 : strlen(s))
86   {}
87   string(string const& s) : string(s.c_str(), s.size()) {}
88   string(string&& s)
89   {
90     string_data::len = s.string_data::len;
91     string_data::data = s.string_data::data;
92     s.string_data::len = 0;
93     s.string_data::data = const_cast<char*>(&NUL);
94   }
95   string(std::string const& s) : string(s.c_str(), s.size()) {}
96
97   // Assign
98   void assign(const char* s, size_t size)
99   {
100     if (string_data::data != &NUL)
101       std::free(string_data::data);
102     if (size == 0) {
103       string_data::len = 0;
104       string_data::data = nullptr;
105     } else {
106       string_data::len = size;
107       string_data::data = (char*) std::malloc(string_data::len + 1);
108       memcpy(string_data::data, s, string_data::len);
109       string_data::data[string_data::len] = '\0';
110     }
111   }
112
113   // Copy
114   string& operator=(const char* s)
115   {
116     assign(s, s == nullptr ? 0 : std::strlen(s));
117     return *this;
118   }
119   string& operator=(string& s)
120   {
121     assign(s.c_str(), s.size());
122     return *this;
123   }
124   string& operator=(std::string& s)
125   {
126     assign(s.c_str(), s.size());
127     return *this;
128   }
129
130   // Capacity
131   size_t size() const   { return len; }
132   size_t length() const { return len; }
133   bool empty() const    { return len != 0; }
134   void shrink_to_fit() {}
135
136   // Alement access
137   char* data()              { return string_data::data; }
138   const char* data()  const { return string_data::data; }
139   char* c_str()             { return string_data::data; }
140   const char* c_str() const { return string_data::data; };
141   reference at(size_type i)
142   {
143     if (i >= size())
144       throw std::out_of_range("Out of range");
145     return data()[i];
146   }
147   const_reference at(size_type i) const
148   {
149     if (i >= size())
150       throw std::out_of_range("Out of range");
151     return data()[i];
152   }
153   reference operator[](size_type i)
154   {
155     return data()[i];
156   }
157   const_reference operator[](size_type i) const
158   {
159     return data()[i];
160   }
161   // Conversion
162   operator std::string() const
163   {
164     return std::string(this->c_str(), this->size());
165   }
166
167   // Iterators
168   iterator begin()               { return data(); }
169   iterator end()                 { return data() + size(); }
170   const_iterator begin() const   { return data(); }
171   const_iterator end() const     { return data() + size(); }
172   const_iterator cbegin() const  { return data(); }
173   const_iterator cend() const    { return data() + size(); }
174   // (Missing, reverse iterators)
175
176   // Operations
177   void clear()
178   {
179     string_data::len = 0;
180     string_data::data = (char*) &NUL;
181   }
182
183   // Compare
184   int compare(string const& that) const
185   {
186     size_t n = std::min(this->size(), that.size());
187     int res = memcmp(this->c_str(), that.c_str(), n);
188     if (res != 0)
189       return res;
190     else if (this->size() == that.size())
191       return 0;
192     else if (this->size() < that.size())
193       return -1;
194     else
195       return 1;
196   }
197   bool operator==(string const& that) const
198   {
199     return this->size() == that.size()
200       && std::memcmp(this->c_str(), that.c_str(), this->size()) == 0;
201   }
202   bool operator!=(string const& that) const
203   {
204     return !(*this == that);
205   }
206   bool operator<(string const& that) const
207   {
208     return compare(that) < 0;
209   }
210   bool operator<=(string const& that) const
211   {
212     return compare(that) <= 0;
213   }
214   bool operator>(string const& that) const
215   {
216     return compare(that) > 0;
217   }
218   bool operator>=(string const& that) const
219   {
220     return compare(that) >= 0;
221   }
222
223   // Compare with std::string
224   bool operator==(std::string const& that) const
225   {
226     return this->size() == that.size()
227       && std::memcmp(this->c_str(), that.c_str(), this->size()) == 0;
228   }
229   bool operator!=(std::string const& that) const
230   {
231     return !(*this == that);
232   }
233   bool operator<(std::string const& that) const
234   {
235     return compare(that) < 0;
236   }
237   bool operator<=(std::string const& that) const
238   {
239     return compare(that) <= 0;
240   }
241   bool operator>(std::string const& that) const
242   {
243     return compare(that) > 0;
244   }
245   bool operator>=(std::string const& that) const
246   {
247     return compare(that) >= 0;
248   }
249 };
250
251 inline
252 bool operator==(std::string const& a, string const& b)
253 {
254   return b == a;
255 }
256 inline
257 bool operator!=(std::string const& a, string const& b)
258 {
259   return b != a;
260 }
261 inline
262 bool operator<(std::string const& a, string const& b)
263 {
264   return b > a;
265 }
266 inline
267 bool operator<=(std::string const& a, string const& b)
268 {
269   return b >= a;
270 }
271 inline
272 bool operator>(std::string const& a, string const& b)
273 {
274   return b < a;
275 }
276 inline
277 bool operator>=(std::string const& a, string const& b)
278 {
279   return b <= a;
280 }
281
282 }
283 }
284
285 #else
286
287 #include <string>
288
289 namespace simgrid {
290 namespace xbt {
291
292 typedef std::string string;
293
294 }
295 }
296
297 #endif
298
299 #endif