boost/python/str.hpp

   1 // Copyright David Abrahams 2002.
   2 // Distributed under the Boost Software License, Version 1.0. (See
   3 // accompanying file LICENSE_1_0.txt or copy at
   4 // http://www.boost.org/LICENSE_1_0.txt)
   5 #ifndef STR_20020703_HPP
   6 #define STR_20020703_HPP
   7
   8 # include <boost/python/detail/prefix.hpp>
   9
  10 #include <boost/python/object.hpp>
  11 #include <boost/python/list.hpp>
  12 #include <boost/python/converter/pytype_object_mgr_traits.hpp>
  13
  14 // disable defines in <cctype> provided by some system libraries
  15 #undef isspace
  16 #undef islower
  17 #undef isalpha
  18 #undef isdigit
  19 #undef isalnum
  20 #undef isupper
  21
  22 namespace boost { namespace python {
  23
  24 class str;
  25
  26 namespace detail
  27 {
  28   struct BOOST_PYTHON_DECL str_base : object
  29   {
  30       str capitalize() const;
  31
  32       str center(object_cref width) const;
  33
  34       long count(object_cref sub) const;
  35
  36       long count(object_cref sub, object_cref start) const;
  37
  38       long count(object_cref sub, object_cref start, object_cref end) const;
  39
  40       object decode() const;
  41       object decode(object_cref encoding) const;
  42
  43       object decode(object_cref encoding, object_cref errors) const;
  44
  45       object encode() const;
  46       object encode(object_cref encoding) const;
  47       object encode(object_cref encoding, object_cref errors) const;
  48
  49       bool endswith(object_cref suffix) const;
  50
  51       bool endswith(object_cref suffix, object_cref start) const;
  52       bool endswith(object_cref suffix, object_cref start, object_cref end) const;
  53
  54       str expandtabs() const;
  55       str expandtabs(object_cref tabsize) const;
  56
  57       long find(object_cref sub) const;
  58       long find(object_cref sub, object_cref start) const;
  59
  60       long find(object_cref sub, object_cref start, object_cref end) const;
  61
  62       long index(object_cref sub) const;
  63
  64       long index(object_cref sub, object_cref start) const;
  65       long index(object_cref sub, object_cref start, object_cref end) const;
  66
  67       bool isalnum() const;
  68       bool isalpha() const;
  69       bool isdigit() const;
  70       bool islower() const;
  71       bool isspace() const;
  72       bool istitle() const;
  73       bool isupper() const;
  74
  75       str join(object_cref sequence) const;
  76
  77       str ljust(object_cref width) const;
  78       str lower() const;
  79       str lstrip() const;
  80
  81       str replace(object_cref old, object_cref new_) const;
  82       str replace(object_cref old, object_cref new_, object_cref maxsplit) const;
  83       long rfind(object_cref sub) const;
  84
  85       long rfind(object_cref sub, object_cref start) const;
  86
  87       long rfind(object_cref sub, object_cref start, object_cref end) const;
  88       long rindex(object_cref sub) const;
  89       long rindex(object_cref sub, object_cref start) const;
  90
  91
  92       long rindex(object_cref sub, object_cref start, object_cref end) const;
  93
  94       str rjust(object_cref width) const;
  95
  96       str rstrip() const;
  97
  98       list split() const;
  99       list split(object_cref sep) const;
 100
 101       list split(object_cref sep, object_cref maxsplit) const;
 102
 103
 104       list splitlines() const;
 105       list splitlines(object_cref keepends) const;
 106
 107       bool startswith(object_cref prefix) const;
 108
 109
 110       bool startswith(object_cref prefix, object_cref start) const;
 111       bool startswith(object_cref prefix, object_cref start, object_cref end) const;
 112
 113       str strip() const;
 114       str swapcase() const;
 115       str title() const;
 116
 117       str translate(object_cref table) const;
 118
 119       str translate(object_cref table, object_cref deletechars) const;
 120
 121
 122       str upper() const;
 123
 124    protected:
 125       str_base(); // new str
 126
 127       str_base(const char* s); // new str
 128
 129       str_base(char const* start, char const* finish);
 130
 131       str_base(char const* start, std::size_t length);
 132
 133       explicit str_base(object_cref other);
 134
 135       BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(str_base, object)
 136    private:
 137       static new_reference call(object const&);
 138   };
 139 }
 140
 141
 142 class str : public detail::str_base
 143 {
 144     typedef detail::str_base base;
 145  public:
 146     str() {} // new str
 147
 148     str(const char* s) : base(s) {} // new str
 149
 150     str(char const* start, char const* finish) // new str
 151       : base(start, finish)
 152     {}
 153
 154     str(char const* start, std::size_t length) // new str
 155       : base(start, length)
 156     {}
 157
 158     template <class T>
 159     explicit str(T const& other)
 160         : base(object(other))
 161     {
 162     }
 163
 164     template <class T>
 165     str center(T const& width) const
 166     {
 167         return base::center(object(width));
 168     }
 169
 170     template<class T>
 171     long count(T const& sub) const
 172     {
 173         return base::count(object(sub));
 174     }
 175
 176     template<class T1, class T2>
 177     long count(T1 const& sub,T2 const& start) const
 178     {
 179         return base::count(object(sub), object(start));
 180     }
 181
 182     template<class T1, class T2, class T3>
 183     long count(T1 const& sub,T2 const& start, T3 const& end) const
 184     {
 185         return base::count(object(sub), object(start));
 186     }
 187
 188     object decode() const { return base::decode(); }
 189
 190     template<class T>
 191     object decode(T const& encoding) const
 192     {
 193         return base::decode(object(encoding));
 194     }
 195
 196     template<class T1, class T2>
 197     object decode(T1 const& encoding, T2 const& errors) const
 198     {
 199         return base::decode(object(encoding),object(errors));
 200     }
 201
 202     object encode() const { return base::encode(); }
 203
 204     template <class T>
 205     object encode(T const& encoding) const
 206     {
 207         return base::encode(object(encoding));
 208     }
 209
 210     template <class T1, class T2>
 211     object encode(T1 const& encoding, T2 const& errors) const
 212     {
 213         return base::encode(object(encoding),object(errors));
 214     }
 215
 216     template <class T>
 217     bool endswith(T const& suffix) const
 218     {
 219         return base::endswith(object(suffix));
 220     }
 221
 222     template <class T1, class T2>
 223     bool endswith(T1 const& suffix, T2 const& start) const
 224     {
 225         return base::endswith(object(suffix), object(start));
 226     }
 227
 228     template <class T1, class T2, class T3>
 229     bool endswith(T1 const& suffix, T2 const& start, T3 const& end) const
 230     {
 231         return base::endswith(object(suffix), object(start), object(end));
 232     }
 233
 234     str expandtabs() const { return base::expandtabs(); }
 235
 236     template <class T>
 237     str expandtabs(T const& tabsize) const
 238     {
 239         return base::expandtabs(object(tabsize));
 240     }
 241
 242     template <class T>
 243     long find(T const& sub) const
 244     {
 245         return base::find(object(sub));
 246     }
 247
 248     template <class T1, class T2>
 249     long find(T1 const& sub, T2 const& start) const
 250     {
 251         return base::find(object(sub), object(start));
 252     }
 253
 254     template <class T1, class T2, class T3>
 255     long find(T1 const& sub, T2 const& start, T3 const& end) const
 256     {
 257         return base::find(object(sub), object(start), object(end));
 258     }
 259
 260     template <class T>
 261     long index(T const& sub) const
 262     {
 263         return base::index(object(sub));
 264     }
 265
 266     template <class T1, class T2>
 267     long index(T1 const& sub, T2 const& start) const
 268     {
 269         return base::index(object(sub), object(start));
 270     }
 271
 272     template <class T1, class T2, class T3>
 273     long index(T1 const& sub, T2 const& start, T3 const& end) const
 274     {
 275         return base::index(object(sub), object(start), object(end));
 276     }
 277
 278     template <class T>
 279     str join(T const& sequence) const
 280     {
 281         return base::join(object(sequence));
 282     }
 283
 284     template <class T>
 285     str ljust(T const& width) const
 286     {
 287         return base::ljust(object(width));
 288     }
 289
 290     template <class T1, class T2>
 291     str replace(T1 const& old, T2 const& new_) const
 292     {
 293         return base::replace(object(old),object(new_));
 294     }
 295
 296     template <class T1, class T2, class T3>
 297     str replace(T1 const& old, T2 const& new_, T3 const& maxsplit) const
 298     {
 299         return base::replace(object(old),object(new_), object(maxsplit));
 300     }
 301
 302     template <class T>
 303     long rfind(T const& sub) const
 304     {
 305         return base::rfind(object(sub));
 306     }
 307
 308     template <class T1, class T2>
 309     long rfind(T1 const& sub, T2 const& start) const
 310     {
 311         return base::rfind(object(sub), object(start));
 312     }
 313
 314     template <class T1, class T2, class T3>
 315     long rfind(T1 const& sub, T2 const& start, T3 const& end) const
 316     {
 317         return base::rfind(object(sub), object(start), object(end));
 318     }
 319
 320     template <class T>
 321     long rindex(T const& sub) const
 322     {
 323         return base::rindex(object(sub));
 324     }
 325
 326     template <class T1, class T2>
 327     long rindex(T1 const& sub, T2 const& start) const
 328     {
 329         return base::rindex(object(sub), object(start));
 330     }
 331
 332     template <class T1, class T2, class T3>
 333     long rindex(T1 const& sub, T2 const& start, T3 const& end) const
 334     {
 335         return base::rindex(object(sub), object(start), object(end));
 336     }
 337
 338     template <class T>
 339     str rjust(T const& width) const
 340     {
 341         return base::rjust(object(width));
 342     }
 343
 344     list split() const { return base::split(); }
 345
 346     template <class T>
 347     list split(T const& sep) const
 348     {
 349         return base::split(object(sep));
 350     }
 351
 352     template <class T1, class T2>
 353     list split(T1 const& sep, T2 const& maxsplit) const
 354     {
 355         return base::split(object(sep), object(maxsplit));
 356     }
 357
 358     list splitlines() const { return base::splitlines(); }
 359
 360     template <class T>
 361     list splitlines(T const& keepends) const
 362     {
 363         return base::splitlines(object(keepends));
 364     }
 365
 366     template <class T>
 367     bool startswith(T const& prefix) const
 368     {
 369         return base::startswith(object(prefix));
 370     }
 371
 372     template <class T1, class T2>
 373     bool startswith(T1 const& prefix, T2 const& start) const
 374     {
 375         return base::startswith(object(prefix), object(start));
 376     }
 377
 378     template <class T1, class T2, class T3>
 379     bool startswith(T1 const& prefix, T2 const& start, T3 const& end) const
 380     {
 381         return base::startswith(object(prefix), object(start), object(end));
 382     }
 383
 384     template <class T>
 385     str translate(T const& table) const
 386     {
 387         return base::translate(object(table));
 388     }
 389
 390     template <class T1, class T2>
 391     str translate(T1 const& table, T2 const& deletechars) const
 392     {
 393         return base::translate(object(table), object(deletechars));
 394     }
 395
 396  public: // implementation detail -- for internal use only
 397     BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(str, base)
 398 };
 399
 400 //
 401 // Converter Specializations
 402 //
 403 namespace converter
 404 {
 405   template <>
 406   struct object_manager_traits<str>
 407       : pytype_object_manager_traits<&PyString_Type,str>
 408   {
 409   };
 410 }
 411
 412 }}  // namespace boost::python
 413
 414 #endif // STR_20020703_HPP