src/support/trivstring.cpp

   1 /**
   2  * \file trivstring.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Georg Baum
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "support/trivstring.h"
  14 #include "support/docstring.h"
  15
  16 #include <algorithm>
  17
  18 using namespace std;
  19
  20 namespace lyx {
  21
  22 template trivial_string<char>::trivial_string(trivial_string const &);
  23 template trivial_string<char_type>::trivial_string(trivial_string const &);
  24 template<typename Char>
  25 trivial_string<Char>::trivial_string(trivial_string const & that) : size_(that.size_)
  26 {
  27         if (use_sso())
  28                 copy(that.data_sso(), that.data_sso() + size_ + 1, data_sso());
  29         else if (size_ > 0) {
  30                 data_ = new Char[size_ + 1];
  31                 copy(that.data_, that.data_ + size_ + 1, data_);
  32         }
  33         // else Happens only for really big Char types
  34 }
  35
  36
  37 template trivial_string<char>::trivial_string(string const &);
  38 template trivial_string<char_type>::trivial_string(docstring const &);
  39 template<typename Char>
  40 trivial_string<Char>::trivial_string(
  41                 basic_string<Char, char_traits<Char>, allocator<Char> > const & that)
  42         : size_(that.length())
  43 {
  44         if (use_sso()) {
  45                 copy(that.begin(), that.end(), data_sso());
  46                 data_sso()[size_] = '\0';
  47         } else if (size_ > 0) {
  48                 data_ = new Char[size_ + 1];
  49                 copy(that.begin(), that.end(), data_);
  50                 data_[size_] = '\0';
  51         }
  52         // else Happens only for really big Char types
  53 }
  54
  55
  56 template trivial_string<char> &
  57 trivial_string<char>::operator=(trivial_string const &);
  58 template trivial_string<char_type> &
  59 trivial_string<char_type>::operator=(trivial_string const &);
  60 template<typename Char>
  61 trivial_string<Char> & trivial_string<Char>::operator=(trivial_string const & that)
  62 {
  63         if (&that == this)
  64                 return *this;
  65         if (!use_sso())
  66                 delete[] data_;
  67         size_ = that.size_;
  68         if (use_sso())
  69                 copy(that.data_sso(), that.data_sso() + size_ + 1, data_sso());
  70         else if (size_ > 0) {
  71                 data_ = new Char[size_ + 1];
  72                 copy(that.data_, that.data_ + size_ + 1, data_);
  73         } else {
  74                 // Happens only for really big Char types
  75                 data_ = 0;
  76         }
  77         return *this;
  78 }
  79
  80
  81 template trivial_string<char> &
  82 trivial_string<char>::operator=(string const &);
  83 template trivial_string<char_type> &
  84 trivial_string<char_type>::operator=(docstring const &);
  85 template<typename Char>
  86 trivial_string<Char> &
  87 trivial_string<Char>::operator=(basic_string<Char, char_traits<Char>, allocator<Char> > const & that)
  88 {
  89         if (!use_sso())
  90                 delete[] data_;
  91         size_ = that.size();
  92         if (use_sso()) {
  93                 copy(that.begin(), that.end(), data_sso());
  94                 data_sso()[size_] = '\0';
  95         } else if (size_ > 0) {
  96                 data_ = new Char[size_ + 1];
  97                 copy(that.begin(), that.end(), data_);
  98         } else {
  99                 // Happens only for really big Char types
 100                 data_ = 0;
 101         }
 102         return *this;
 103 }
 104
 105
 106 template void
 107 trivial_string<char>::swap(trivial_string<char> &);
 108 template void
 109 trivial_string<char_type>::swap(trivial_string<char_type> &);
 110 template<typename Char>
 111 void trivial_string<Char>::swap(trivial_string & that)
 112 {
 113         size_t const sizetmp = that.size_;
 114         that.size_ = size_;
 115         size_ = sizetmp;
 116         Char * const datatmp = that.data_;
 117         that.data_ = data_;
 118         data_ = datatmp;
 119 }
 120
 121
 122 template<typename Char>
 123 int trivial_string<Char>::compare(trivial_string const & other) const
 124 {
 125         size_t const lsize = this->length();
 126         size_t const rsize = other.length();
 127         size_t const len = min(lsize, rsize);
 128         int r = char_traits<Char>::compare(c_str(), other.c_str(), len);
 129         if (r == 0) {
 130                 if (lsize > rsize)
 131                         r = 1;
 132                 else if (lsize < rsize)
 133                         r = -1;
 134         }
 135         return r;
 136 }
 137
 138
 139 template string trivial_string<char>::str() const;
 140 template docstring trivial_string<char_type>::str() const;
 141 template<typename Char>
 142 basic_string<Char, char_traits<Char>, allocator<Char> >
 143 trivial_string<Char>::str() const
 144 {
 145         if (use_sso())
 146                 return basic_string<Char, char_traits<Char>, allocator<Char> >(
 147                                 data_sso(), size_);
 148         if (size_ > 0)
 149                 return basic_string<Char, char_traits<Char>, allocator<Char> >(
 150                                 data_, size_);
 151         // Happens only for really big Char types
 152         return basic_string<Char, char_traits<Char>, allocator<Char> >();
 153 }
 154
 155
 156 template char const * trivial_string<char>::c_str() const;
 157 template char_type const * trivial_string<char_type>::c_str() const;
 158 template<typename Char> Char const * trivial_string<Char>::c_str() const
 159 {
 160         if (use_sso())
 161                 return data_sso();
 162         if (size_ > 0)
 163                 return data_;
 164         // Happens only for really big Char types
 165         static const Char empty_char = '\0';
 166         return &empty_char;
 167 }
 168
 169
 170 template bool operator<(trivial_string<char> const &,
 171                         trivial_string<char> const &);
 172 template bool operator<(trivial_string<char_type> const &,
 173                         trivial_string<char_type> const &);
 174 template <typename Char>
 175 bool operator<(trivial_string<Char> const & lhs, trivial_string<Char> const &rhs)
 176 {
 177         return lhs.compare(rhs) < 0;
 178 }
 179
 180 } // namespace lyx