"Fossies" - the Fresh Open Source Software Archive

Member "icinga2-2.10.5/lib/base/string.cpp" (23 May 2019, 9328 Bytes) of package /linux/misc/icinga2-2.10.5.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "string.cpp" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 2.10.0_vs_2.10.1.

    1 /******************************************************************************
    2  * Icinga 2                                                                   *
    3  * Copyright (C) 2012-2018 Icinga Development Team (https://icinga.com/)      *
    4  *                                                                            *
    5  * This program is free software; you can redistribute it and/or              *
    6  * modify it under the terms of the GNU General Public License                *
    7  * as published by the Free Software Foundation; either version 2             *
    8  * of the License, or (at your option) any later version.                     *
    9  *                                                                            *
   10  * This program is distributed in the hope that it will be useful,            *
   11  * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
   12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
   13  * GNU General Public License for more details.                               *
   14  *                                                                            *
   15  * You should have received a copy of the GNU General Public License          *
   16  * along with this program; if not, write to the Free Software Foundation     *
   17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.             *
   18  ******************************************************************************/
   19 
   20 #include "base/string.hpp"
   21 #include "base/value.hpp"
   22 #include "base/primitivetype.hpp"
   23 #include "base/dictionary.hpp"
   24 #include <boost/algorithm/string/case_conv.hpp>
   25 #include <boost/algorithm/string/trim.hpp>
   26 #include <boost/algorithm/string/split.hpp>
   27 #include <ostream>
   28 
   29 using namespace icinga;
   30 
   31 template class std::vector<String>;
   32 
   33 REGISTER_BUILTIN_TYPE(String, String::GetPrototype());
   34 
   35 const String::SizeType String::NPos = std::string::npos;
   36 
   37 String::String(const char *data)
   38     : m_Data(data)
   39 { }
   40 
   41 String::String(std::string data)
   42     : m_Data(std::move(data))
   43 { }
   44 
   45 String::String(String::SizeType n, char c)
   46     : m_Data(n, c)
   47 { }
   48 
   49 String::String(const String& other)
   50     : m_Data(other)
   51 { }
   52 
   53 String::String(String&& other)
   54     : m_Data(std::move(other.m_Data))
   55 { }
   56 
   57 #ifndef _MSC_VER
   58 String::String(Value&& other)
   59 {
   60     *this = std::move(other);
   61 }
   62 #endif /* _MSC_VER */
   63 
   64 String& String::operator=(Value&& other)
   65 {
   66     if (other.IsString())
   67         m_Data = std::move(other.Get<String>());
   68     else
   69         *this = static_cast<String>(other);
   70 
   71     return *this;
   72 }
   73 
   74 String& String::operator+=(const Value& rhs)
   75 {
   76     m_Data += static_cast<String>(rhs);
   77     return *this;
   78 }
   79 
   80 String& String::operator=(const String& rhs)
   81 {
   82     m_Data = rhs.m_Data;
   83     return *this;
   84 }
   85 
   86 String& String::operator=(String&& rhs)
   87 {
   88     m_Data = std::move(rhs.m_Data);
   89     return *this;
   90 }
   91 
   92 String& String::operator=(const std::string& rhs)
   93 {
   94     m_Data = rhs;
   95     return *this;
   96 }
   97 
   98 String& String::operator=(const char *rhs)
   99 {
  100     m_Data = rhs;
  101     return *this;
  102 }
  103 
  104 const char& String::operator[](String::SizeType pos) const
  105 {
  106     return m_Data[pos];
  107 }
  108 
  109 char& String::operator[](String::SizeType pos)
  110 {
  111     return m_Data[pos];
  112 }
  113 
  114 String& String::operator+=(const String& rhs)
  115 {
  116     m_Data += rhs.m_Data;
  117     return *this;
  118 }
  119 
  120 String& String::operator+=(const char *rhs)
  121 {
  122     m_Data += rhs;
  123     return *this;
  124 }
  125 
  126 String& String::operator+=(char rhs)
  127 {
  128     m_Data += rhs;
  129     return *this;
  130 }
  131 
  132 bool String::IsEmpty() const
  133 {
  134     return m_Data.empty();
  135 }
  136 
  137 bool String::operator<(const String& rhs) const
  138 {
  139     return m_Data < rhs.m_Data;
  140 }
  141 
  142 String::operator const std::string&() const
  143 {
  144     return m_Data;
  145 }
  146 
  147 const char *String::CStr() const
  148 {
  149     return m_Data.c_str();
  150 }
  151 
  152 void String::Clear()
  153 {
  154     m_Data.clear();
  155 }
  156 
  157 String::SizeType String::GetLength() const
  158 {
  159     return m_Data.size();
  160 }
  161 
  162 std::string& String::GetData()
  163 {
  164     return m_Data;
  165 }
  166 
  167 const std::string& String::GetData() const
  168 {
  169     return m_Data;
  170 }
  171 
  172 String::SizeType String::Find(const String& str, String::SizeType pos) const
  173 {
  174     return m_Data.find(str, pos);
  175 }
  176 
  177 String::SizeType String::RFind(const String& str, String::SizeType pos) const
  178 {
  179     return m_Data.rfind(str, pos);
  180 }
  181 
  182 String::SizeType String::FindFirstOf(const char *s, String::SizeType pos) const
  183 {
  184     return m_Data.find_first_of(s, pos);
  185 }
  186 
  187 String::SizeType String::FindFirstOf(char ch, String::SizeType pos) const
  188 {
  189     return m_Data.find_first_of(ch, pos);
  190 }
  191 
  192 String::SizeType String::FindFirstNotOf(const char *s, String::SizeType pos) const
  193 {
  194     return m_Data.find_first_not_of(s, pos);
  195 }
  196 
  197 String::SizeType String::FindFirstNotOf(char ch, String::SizeType pos) const
  198 {
  199     return m_Data.find_first_not_of(ch, pos);
  200 }
  201 
  202 String::SizeType String::FindLastOf(const char *s, String::SizeType pos) const
  203 {
  204     return m_Data.find_last_of(s, pos);
  205 }
  206 
  207 String::SizeType String::FindLastOf(char ch, String::SizeType pos) const
  208 {
  209     return m_Data.find_last_of(ch, pos);
  210 }
  211 
  212 String String::SubStr(String::SizeType first, String::SizeType len) const
  213 {
  214     return m_Data.substr(first, len);
  215 }
  216 
  217 std::vector<String> String::Split(const char *separators) const
  218 {
  219     std::vector<String> result;
  220     boost::algorithm::split(result, m_Data, boost::is_any_of(separators));
  221     return result;
  222 }
  223 
  224 void String::Replace(String::SizeType first, String::SizeType second, const String& str)
  225 {
  226     m_Data.replace(first, second, str);
  227 }
  228 
  229 String String::Trim() const
  230 {
  231     String t = m_Data;
  232     boost::algorithm::trim(t);
  233     return t;
  234 }
  235 
  236 String String::ToLower() const
  237 {
  238     String t = m_Data;
  239     boost::algorithm::to_lower(t);
  240     return t;
  241 }
  242 
  243 String String::ToUpper() const
  244 {
  245     String t = m_Data;
  246     boost::algorithm::to_upper(t);
  247     return t;
  248 }
  249 
  250 String String::Reverse() const
  251 {
  252     String t = m_Data;
  253     std::reverse(t.m_Data.begin(), t.m_Data.end());
  254     return t;
  255 }
  256 
  257 void String::Append(int count, char ch)
  258 {
  259     m_Data.append(count, ch);
  260 }
  261 
  262 bool String::Contains(const String& str) const
  263 {
  264     return (m_Data.find(str) != std::string::npos);
  265 }
  266 
  267 void String::swap(String& str)
  268 {
  269     m_Data.swap(str.m_Data);
  270 }
  271 
  272 String::Iterator String::erase(String::Iterator first, String::Iterator last)
  273 {
  274     return m_Data.erase(first, last);
  275 }
  276 
  277 String::Iterator String::Begin()
  278 {
  279     return m_Data.begin();
  280 }
  281 
  282 String::ConstIterator String::Begin() const
  283 {
  284     return m_Data.begin();
  285 }
  286 
  287 String::Iterator String::End()
  288 {
  289     return m_Data.end();
  290 }
  291 
  292 String::ConstIterator String::End() const
  293 {
  294     return m_Data.end();
  295 }
  296 
  297 String::ReverseIterator String::RBegin()
  298 {
  299     return m_Data.rbegin();
  300 }
  301 
  302 String::ConstReverseIterator String::RBegin() const
  303 {
  304     return m_Data.rbegin();
  305 }
  306 
  307 String::ReverseIterator String::REnd()
  308 {
  309     return m_Data.rend();
  310 }
  311 
  312 String::ConstReverseIterator String::REnd() const
  313 {
  314     return m_Data.rend();
  315 }
  316 
  317 std::ostream& icinga::operator<<(std::ostream& stream, const String& str)
  318 {
  319     stream << str.GetData();
  320     return stream;
  321 }
  322 
  323 std::istream& icinga::operator>>(std::istream& stream, String& str)
  324 {
  325     std::string tstr;
  326     stream >> tstr;
  327     str = tstr;
  328     return stream;
  329 }
  330 
  331 String icinga::operator+(const String& lhs, const String& rhs)
  332 {
  333     return lhs.GetData() + rhs.GetData();
  334 }
  335 
  336 String icinga::operator+(const String& lhs, const char *rhs)
  337 {
  338     return lhs.GetData() + rhs;
  339 }
  340 
  341 String icinga::operator+(const char *lhs, const String& rhs)
  342 {
  343     return lhs + rhs.GetData();
  344 }
  345 
  346 bool icinga::operator==(const String& lhs, const String& rhs)
  347 {
  348     return lhs.GetData() == rhs.GetData();
  349 }
  350 
  351 bool icinga::operator==(const String& lhs, const char *rhs)
  352 {
  353     return lhs.GetData() == rhs;
  354 }
  355 
  356 bool icinga::operator==(const char *lhs, const String& rhs)
  357 {
  358     return lhs == rhs.GetData();
  359 }
  360 
  361 bool icinga::operator<(const String& lhs, const char *rhs)
  362 {
  363     return lhs.GetData() < rhs;
  364 }
  365 
  366 bool icinga::operator<(const char *lhs, const String& rhs)
  367 {
  368     return lhs < rhs.GetData();
  369 }
  370 
  371 bool icinga::operator>(const String& lhs, const String& rhs)
  372 {
  373     return lhs.GetData() > rhs.GetData();
  374 }
  375 
  376 bool icinga::operator>(const String& lhs, const char *rhs)
  377 {
  378     return lhs.GetData() > rhs;
  379 }
  380 
  381 bool icinga::operator>(const char *lhs, const String& rhs)
  382 {
  383     return lhs > rhs.GetData();
  384 }
  385 
  386 bool icinga::operator<=(const String& lhs, const String& rhs)
  387 {
  388     return lhs.GetData() <= rhs.GetData();
  389 }
  390 
  391 bool icinga::operator<=(const String& lhs, const char *rhs)
  392 {
  393     return lhs.GetData() <= rhs;
  394 }
  395 
  396 bool icinga::operator<=(const char *lhs, const String& rhs)
  397 {
  398     return lhs <= rhs.GetData();
  399 }
  400 
  401 bool icinga::operator>=(const String& lhs, const String& rhs)
  402 {
  403     return lhs.GetData() >= rhs.GetData();
  404 }
  405 
  406 bool icinga::operator>=(const String& lhs, const char *rhs)
  407 {
  408     return lhs.GetData() >= rhs;
  409 }
  410 
  411 bool icinga::operator>=(const char *lhs, const String& rhs)
  412 {
  413     return lhs >= rhs.GetData();
  414 }
  415 
  416 bool icinga::operator!=(const String& lhs, const String& rhs)
  417 {
  418     return lhs.GetData() != rhs.GetData();
  419 }
  420 
  421 bool icinga::operator!=(const String& lhs, const char *rhs)
  422 {
  423     return lhs.GetData() != rhs;
  424 }
  425 
  426 bool icinga::operator!=(const char *lhs, const String& rhs)
  427 {
  428     return lhs != rhs.GetData();
  429 }
  430 
  431 String::Iterator icinga::begin(String& x)
  432 {
  433     return x.Begin();
  434 }
  435 
  436 String::ConstIterator icinga::begin(const String& x)
  437 {
  438     return x.Begin();
  439 }
  440 
  441 String::Iterator icinga::end(String& x)
  442 {
  443     return x.End();
  444 }
  445 
  446 String::ConstIterator icinga::end(const String& x)
  447 {
  448     return x.End();
  449 }
  450 String::Iterator icinga::range_begin(String& x)
  451 {
  452     return x.Begin();
  453 }
  454 
  455 String::ConstIterator icinga::range_begin(const String& x)
  456 {
  457     return x.Begin();
  458 }
  459 
  460 String::Iterator icinga::range_end(String& x)
  461 {
  462     return x.End();
  463 }
  464 
  465 String::ConstIterator icinga::range_end(const String& x)
  466 {
  467     return x.End();
  468 }