summaryrefslogtreecommitdiffstats
path: root/ml/dlib/dlib/string
diff options
context:
space:
mode:
Diffstat (limited to 'ml/dlib/dlib/string')
-rw-r--r--ml/dlib/dlib/string/cassert1
-rw-r--r--ml/dlib/dlib/string/iomanip1
-rw-r--r--ml/dlib/dlib/string/iosfwd1
-rw-r--r--ml/dlib/dlib/string/iostream1
-rw-r--r--ml/dlib/dlib/string/locale1
-rw-r--r--ml/dlib/dlib/string/string.h1004
-rw-r--r--ml/dlib/dlib/string/string_abstract.h652
7 files changed, 1661 insertions, 0 deletions
diff --git a/ml/dlib/dlib/string/cassert b/ml/dlib/dlib/string/cassert
new file mode 100644
index 000000000..6139ba823
--- /dev/null
+++ b/ml/dlib/dlib/string/cassert
@@ -0,0 +1 @@
+#include "../dlib_include_path_tutorial.txt"
diff --git a/ml/dlib/dlib/string/iomanip b/ml/dlib/dlib/string/iomanip
new file mode 100644
index 000000000..6139ba823
--- /dev/null
+++ b/ml/dlib/dlib/string/iomanip
@@ -0,0 +1 @@
+#include "../dlib_include_path_tutorial.txt"
diff --git a/ml/dlib/dlib/string/iosfwd b/ml/dlib/dlib/string/iosfwd
new file mode 100644
index 000000000..6139ba823
--- /dev/null
+++ b/ml/dlib/dlib/string/iosfwd
@@ -0,0 +1 @@
+#include "../dlib_include_path_tutorial.txt"
diff --git a/ml/dlib/dlib/string/iostream b/ml/dlib/dlib/string/iostream
new file mode 100644
index 000000000..6139ba823
--- /dev/null
+++ b/ml/dlib/dlib/string/iostream
@@ -0,0 +1 @@
+#include "../dlib_include_path_tutorial.txt"
diff --git a/ml/dlib/dlib/string/locale b/ml/dlib/dlib/string/locale
new file mode 100644
index 000000000..6139ba823
--- /dev/null
+++ b/ml/dlib/dlib/string/locale
@@ -0,0 +1 @@
+#include "../dlib_include_path_tutorial.txt"
diff --git a/ml/dlib/dlib/string/string.h b/ml/dlib/dlib/string/string.h
new file mode 100644
index 000000000..2c2602198
--- /dev/null
+++ b/ml/dlib/dlib/string/string.h
@@ -0,0 +1,1004 @@
+// Copyright (C) 2006 Davis E. King (davis@dlib.net)
+// License: Boost Software License See LICENSE.txt for the full license.
+#ifndef DLIB_STRINg_
+#define DLIB_STRINg_
+
+#include "string_abstract.h"
+#include <sstream>
+#include "../algs.h"
+#include <string>
+#include <iostream>
+#include <iomanip>
+#include "../error.h"
+#include "../assert.h"
+#include "../uintn.h"
+#include <cctype>
+#include <algorithm>
+#include <vector>
+#include "../enable_if.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ inline const typename disable_if<is_same_type<charT,char>,std::string>::type narrow (
+ const std::basic_string<charT,traits,alloc>& str
+ )
+ {
+ std::string temp;
+ temp.reserve(str.size());
+ std::string::size_type i;
+ for (i = 0; i < str.size(); ++i)
+ {
+ if (zero_extend_cast<unsigned long>(str[i]) > 255)
+ temp += ' ';
+ else
+ temp += zero_extend_cast<char>(str[i]);
+ }
+ return temp;
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ inline const typename enable_if<is_same_type<charT,char>,std::string>::type narrow (
+ const std::basic_string<charT,traits,alloc>& str
+ )
+ {
+ return str;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<char,traits,alloc> tolower (
+ const std::basic_string<char,traits,alloc>& str
+ )
+ {
+ std::basic_string<char,traits,alloc> temp;
+
+ temp.resize(str.size());
+
+ for (typename std::basic_string<char,traits,alloc>::size_type i = 0; i < str.size(); ++i)
+ temp[i] = (char)std::tolower(str[i]);
+
+ return temp;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<char,traits,alloc> toupper (
+ const std::basic_string<char,traits,alloc>& str
+ )
+ {
+ std::basic_string<char,traits,alloc> temp;
+
+ temp.resize(str.size());
+
+ for (typename std::basic_string<char,traits,alloc>::size_type i = 0; i < str.size(); ++i)
+ temp[i] = (char)std::toupper(str[i]);
+
+ return temp;
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ bool strings_equal_ignore_case (
+ const std::basic_string<char,traits,alloc>& str1,
+ const std::basic_string<char,traits,alloc>& str2
+ )
+ {
+ if (str1.size() != str2.size())
+ return false;
+
+ for (typename std::basic_string<char,traits,alloc>::size_type i = 0; i < str1.size(); ++i)
+ {
+ if (std::tolower(str1[i]) != std::tolower(str2[i]))
+ return false;
+ }
+
+ return true;
+ }
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ bool strings_equal_ignore_case (
+ const std::basic_string<char,traits,alloc>& str1,
+ const char* str2
+ )
+ {
+ typename std::basic_string<char,traits,alloc>::size_type i;
+ for (i = 0; i < str1.size(); ++i)
+ {
+ // if we hit the end of str2 then the strings aren't the same length
+ if (str2[i] == '\0')
+ return false;
+
+ if (std::tolower(str1[i]) != std::tolower(str2[i]))
+ return false;
+ }
+
+ // This happens when str2 is longer than str1
+ if (str2[i] != '\0')
+ return false;
+
+ return true;
+ }
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ bool strings_equal_ignore_case (
+ const char* str1,
+ const std::basic_string<char,traits,alloc>& str2
+ )
+ {
+ return strings_equal_ignore_case(str2, str1);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ bool strings_equal_ignore_case (
+ const std::basic_string<char,traits,alloc>& str1,
+ const std::basic_string<char,traits,alloc>& str2,
+ unsigned long num
+ )
+ {
+ if (str1.size() != str2.size() && (str1.size() < num || str2.size() < num))
+ return false;
+
+ for (typename std::basic_string<char,traits,alloc>::size_type i = 0; i < str1.size() && i < num; ++i)
+ {
+ if (std::tolower(str1[i]) != std::tolower(str2[i]))
+ return false;
+ }
+
+ return true;
+ }
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ bool strings_equal_ignore_case (
+ const std::basic_string<char,traits,alloc>& str1,
+ const char* str2,
+ unsigned long num
+ )
+ {
+ typename std::basic_string<char,traits,alloc>::size_type i;
+ for (i = 0; i < str1.size() && i < num; ++i)
+ {
+ // if we hit the end of str2 then the strings aren't the same length
+ if (str2[i] == '\0')
+ return false;
+
+ if (std::tolower(str1[i]) != std::tolower(str2[i]))
+ return false;
+ }
+
+ return true;
+ }
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ bool strings_equal_ignore_case (
+ const char* str1,
+ const std::basic_string<char,traits,alloc>& str2,
+ unsigned long num
+ )
+ {
+ return strings_equal_ignore_case(str2, str1, num);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ class cast_to_string_error : public error
+ {
+ public:
+ cast_to_string_error():error(ECAST_TO_STRING) {}
+ };
+
+ template <
+ typename T
+ >
+ const std::string cast_to_string (
+ const T& item
+ )
+ {
+ std::ostringstream sout;
+ sout << item;
+ if (!sout)
+ throw cast_to_string_error();
+ return sout.str();
+ }
+
+ // don't declare this if we are using mingw because it apparently doesn't
+ // support iostreams with wchar_t?
+#if !(defined(__MINGW32__) && (__GNUC__ < 4))
+ template <
+ typename T
+ >
+ const std::wstring cast_to_wstring (
+ const T& item
+ )
+ {
+ std::basic_ostringstream<wchar_t> sout;
+ sout << item;
+ if (!sout)
+ throw cast_to_string_error();
+ return sout.str();
+ }
+#endif
+
+// ----------------------------------------------------------------------------------------
+
+ inline std::string pad_int_with_zeros (
+ int i,
+ unsigned long width = 6
+ )
+ {
+ std::ostringstream sout;
+ sout << std::setw(width) << std::setfill('0') << i;
+ return sout.str();
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ class string_cast_error : public error
+ {
+ public:
+ string_cast_error(const std::string& str):
+ error(ESTRING_CAST,"string cast error: invalid string = '" + str + "'") {}
+ };
+
+ template <
+ typename T
+ >
+ struct string_cast_helper
+ {
+ template < typename charT, typename traits, typename alloc >
+ static const T cast (
+ const std::basic_string<charT,traits,alloc>& str
+ )
+ {
+ using namespace std;
+ basic_istringstream<charT,traits,alloc> sin(str);
+ T temp;
+ sin >> temp;
+ if (!sin) throw string_cast_error(narrow(str));
+ if (sin.get() != std::char_traits<charT>::eof()) throw string_cast_error(narrow(str));
+ return temp;
+ }
+ };
+
+ template <typename C, typename T, typename A>
+ struct string_cast_helper<std::basic_string<C,T,A> >
+ {
+ template < typename charT, typename traits, typename alloc >
+ static const std::basic_string<C,T,A> cast (
+ const std::basic_string<charT,traits,alloc>& str
+ )
+ {
+ std::basic_string<C,T,A> temp;
+ temp.resize(str.size());
+ for (unsigned long i = 0; i < str.size(); ++i)
+ temp[i] = zero_extend_cast<C>(str[i]);
+ return temp;
+ }
+ };
+
+ template <>
+ struct string_cast_helper<bool>
+ {
+ template < typename charT, typename traits, typename alloc >
+ static bool cast (
+ const std::basic_string<charT,traits,alloc>& str
+ )
+ {
+ using namespace std;
+ if (str.size() == 1 && str[0] == '1')
+ return true;
+ if (str.size() == 1 && str[0] == '0')
+ return false;
+ if (tolower(narrow(str)) == "true")
+ return true;
+ if (tolower(narrow(str)) == "false")
+ return false;
+
+ throw string_cast_error(narrow(str));
+ }
+ };
+
+#define DLIB_STRING_CAST_INTEGRAL(type) \
+ template <> \
+ struct string_cast_helper<type> \
+ { \
+ template < typename charT, typename traits, typename alloc> \
+ static type cast ( \
+ const std::basic_string<charT,traits,alloc>& str \
+ ) \
+ { \
+ using namespace std; \
+ basic_istringstream<charT,traits,alloc> sin(str); \
+ type temp; \
+ if (str.size() > 2 && str[0] == _dT(charT,'0') && str[1] == _dT(charT,'x')) \
+ sin >> hex >> temp; \
+ else \
+ sin >> temp; \
+ if (!sin) throw string_cast_error(narrow(str)); \
+ if (sin.get() != std::char_traits<charT>::eof()) throw string_cast_error(narrow(str)); \
+ return temp; \
+ } \
+ };
+
+ DLIB_STRING_CAST_INTEGRAL(unsigned short)
+ DLIB_STRING_CAST_INTEGRAL(short)
+ DLIB_STRING_CAST_INTEGRAL(unsigned int)
+ DLIB_STRING_CAST_INTEGRAL(int)
+ DLIB_STRING_CAST_INTEGRAL(unsigned long)
+ DLIB_STRING_CAST_INTEGRAL(long)
+ DLIB_STRING_CAST_INTEGRAL(uint64)
+
+ template <
+ typename T,
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ inline const T string_cast (
+ const std::basic_string<charT,traits,alloc>& str
+ )
+ {
+ COMPILE_TIME_ASSERT(is_pointer_type<T>::value == false);
+ return string_cast_helper<T>::cast(str);
+ }
+
+ template <typename T>
+ inline const T string_cast (const char* str){ return string_cast<T>(std::string(str)); }
+ template <typename T>
+ inline const T string_cast (const wchar_t* str){ return string_cast<T>(std::wstring(str)); }
+
+// ----------------------------------------------------------------------------------------
+
+ class string_assign
+ {
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ class string_assign_helper
+ {
+ public:
+ string_assign_helper (
+ const std::basic_string<charT,traits,alloc>& str_
+ ) : str(str_) {}
+
+ template <typename T>
+ operator T () const
+ {
+ return string_cast<T>(str);
+ }
+
+ private:
+
+ const std::basic_string<charT,traits,alloc>& str;
+ };
+
+ // -------------
+
+ class char_assign_helper
+ {
+ public:
+ char_assign_helper (
+ const char* str_
+ ) : str(str_) {}
+
+ template <typename T>
+ operator T () const
+ {
+ return string_cast<T>(str);
+ }
+
+ private:
+
+ const char* str;
+ };
+
+ // -------------
+
+ class wchar_t_assign_helper
+ {
+ public:
+ wchar_t_assign_helper (
+ const wchar_t* str_
+ ) : str(str_) {}
+
+ template <typename T>
+ operator T () const
+ {
+ return string_cast<T>(str);
+ }
+
+ private:
+
+ const wchar_t* str;
+ };
+
+ // -------------
+
+ public:
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ string_assign_helper<charT,traits,alloc> operator=(
+ const std::basic_string<charT,traits,alloc>& str
+ ) const
+ {
+ return string_assign_helper<charT,traits,alloc>(str);
+ }
+
+ char_assign_helper operator= (
+ const char* str
+ ) const
+ {
+ return char_assign_helper(str);
+ }
+
+ wchar_t_assign_helper operator= (
+ const wchar_t* str
+ ) const
+ {
+ return wchar_t_assign_helper(str);
+ }
+ };
+
+ const string_assign sa = string_assign();
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> wrap_string (
+ const std::basic_string<charT,traits,alloc>& str,
+ const unsigned long first_pad = 0,
+ const unsigned long rest_pad = 0,
+ const unsigned long max_per_line = 79
+ )
+ {
+ DLIB_ASSERT ( first_pad < max_per_line && rest_pad < max_per_line &&
+ rest_pad >= first_pad,
+ "\tconst std::basic_string<charT,traits,alloc> wrap_string()"
+ << "\n\tfirst_pad: " << first_pad
+ << "\n\trest_pad: " << rest_pad
+ << "\n\tmax_per_line: " << max_per_line );
+
+ using namespace std;
+
+ basic_ostringstream<charT,traits,alloc> sout;
+ basic_istringstream<charT,traits,alloc> sin(str);
+
+ for (unsigned long i = 0; i < rest_pad; ++i)
+ sout << _dT(charT," ");
+ const basic_string<charT,traits,alloc> pad(sout.str());
+ sout.str(_dT(charT,""));
+
+ for (unsigned long i = 0; i < first_pad; ++i)
+ sout << _dT(charT," ");
+
+
+ typename basic_string<charT,traits,alloc>::size_type remaining = max_per_line - rest_pad;
+
+ basic_string<charT,traits,alloc> temp;
+
+ sin >> temp;
+ while (sin)
+ {
+ if (temp.size() > remaining)
+ {
+ if (temp.size() + rest_pad >= max_per_line)
+ {
+ string::size_type i = 0;
+ for (; i < temp.size(); ++i)
+ {
+ sout << temp[i];
+ --remaining;
+ if (remaining == 0)
+ {
+ sout << _dT(charT,"\n") << pad;
+ remaining = max_per_line - rest_pad;
+ }
+ }
+ }
+ else
+ {
+ sout << _dT(charT,"\n") << pad << temp;
+ remaining = max_per_line - rest_pad - temp.size();
+ }
+ }
+ else if (temp.size() == remaining)
+ {
+ sout << temp;
+ remaining = 0;
+ }
+ else
+ {
+ sout << temp;
+ remaining -= temp.size();
+ }
+
+ sin >> temp;
+ if (remaining == 0 && sin)
+ {
+ sout << _dT(charT,"\n") << pad;
+ remaining = max_per_line - rest_pad;
+ }
+ else
+ {
+ sout << _dT(charT," ");
+ --remaining;
+ }
+ }
+
+ return sout.str();
+ }
+
+ template <
+ typename charT
+ >
+ const std::basic_string<charT> wrap_string (
+ const charT* str,
+ const unsigned long first_pad = 0,
+ const unsigned long rest_pad = 0,
+ const unsigned long max_per_line = 79
+ ) { return wrap_string(std::basic_string<charT>(str),first_pad,rest_pad,max_per_line); }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> ltrim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& trim_chars
+ )
+ {
+ typedef std::basic_string<charT,traits,alloc> string;
+ typename string::size_type pos = str.find_first_not_of(trim_chars);
+ if (pos != string::npos)
+ return str.substr(pos);
+ else
+ return std::basic_string<charT,traits,alloc>();
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> ltrim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* trim_chars = _dT(charT," \t\r\n")
+ ) { return ltrim(str,std::basic_string<charT,traits,alloc>(trim_chars)); }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> rtrim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& trim_chars
+ )
+ {
+ typedef std::basic_string<charT,traits,alloc> string;
+
+ typename string::size_type pos = str.find_last_not_of(trim_chars);
+ if (pos != string::npos)
+ return str.substr(0,pos+1);
+ else
+ return std::basic_string<charT,traits,alloc>();
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> rtrim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* trim_chars = _dT(charT," \t\r\n")
+ ) { return rtrim(str,std::basic_string<charT,traits,alloc>(trim_chars)); }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> trim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& trim_chars
+ )
+ {
+ typedef std::basic_string<charT,traits,alloc> string;
+ typename string::size_type lpos = str.find_first_not_of(trim_chars);
+ if (lpos != string::npos)
+ {
+ typename string::size_type rpos = str.find_last_not_of(trim_chars);
+ return str.substr(lpos,rpos-lpos+1);
+ }
+ else
+ {
+ return std::basic_string<charT,traits,alloc>();
+ }
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> trim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* trim_chars = _dT(charT," \t\r\n")
+ ) { return trim(str,std::basic_string<charT,traits,alloc>(trim_chars)); }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> rpad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const std::basic_string<charT,traits,alloc>& pad_string
+ )
+ {
+ typedef std::basic_string<charT,traits,alloc> string;
+ // if str is too big then just return str
+ if (pad_length <= static_cast<long>(str.size()))
+ return str;
+
+ // make the string we will padd onto the string
+ string P;
+ while (P.size() < pad_length - str.size())
+ P += pad_string;
+ P = P.substr(0,pad_length - str.size());
+
+ // return the padded string
+ return str + P;
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> rpad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const charT* pad_string = _dT(charT," ")
+ ) { return rpad(str,pad_length,std::basic_string<charT,traits,alloc>(pad_string)); }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> lpad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const std::basic_string<charT,traits,alloc>& pad_string
+ )
+ {
+ typedef std::basic_string<charT,traits,alloc> string;
+ // if str is too big then just return str
+ if (pad_length <= static_cast<long>(str.size()))
+ return str;
+
+ // make the string we will padd onto the string
+ string P;
+ while (P.size() < pad_length - str.size())
+ P += pad_string;
+ P = P.substr(0,pad_length - str.size());
+
+ // return the padded string
+ return P + str;
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> lpad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const charT* pad_string = _dT(charT," ")
+ ) { return lpad(str,pad_length,std::basic_string<charT,traits,alloc>(pad_string)); }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> pad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const std::basic_string<charT,traits,alloc>& pad_string
+ )
+ {
+ const long str_size = static_cast<long>(str.size());
+ return rpad(lpad(str,(pad_length-str_size)/2 + str_size,pad_string),
+ pad_length,
+ pad_string);
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> pad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const charT* pad_string = _dT(charT," ")
+ ) { return pad(str,pad_length,std::basic_string<charT,traits,alloc>(pad_string)); }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> left_substr (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ )
+ {
+ return str.substr(0,str.find_first_of(delim));
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> left_substr (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT," \n\r\t")
+ )
+ {
+ return str.substr(0,str.find_first_of(delim));
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> right_substr (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ )
+ {
+ typename std::basic_string<charT,traits,alloc>::size_type delim_pos = str.find_last_of(delim);
+ if (delim_pos != std::basic_string<charT,traits,alloc>::npos)
+ return str.substr(delim_pos+1);
+ else
+ return _dT(charT,"");
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> right_substr (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT," \n\r\t")
+ )
+ {
+ typename std::basic_string<charT,traits,alloc>::size_type delim_pos = str.find_last_of(delim);
+ if (delim_pos != std::basic_string<charT,traits,alloc>::npos)
+ return str.substr(delim_pos+1);
+ else
+ return _dT(charT,"");
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ std::pair<std::basic_string<charT,traits,alloc>, std::basic_string<charT,traits,alloc> >
+ split_on_first (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT," \n\r\t")
+ )
+ {
+ typename std::basic_string<charT,traits,alloc>::size_type delim_pos = str.find_first_of(delim);
+ if (delim_pos != std::basic_string<charT,traits,alloc>::npos)
+ return std::make_pair(str.substr(0, delim_pos), str.substr(delim_pos+1));
+ else
+ return std::make_pair(str, _dT(charT,""));
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ inline std::pair<std::basic_string<charT,traits,alloc>, std::basic_string<charT,traits,alloc> >
+ split_on_first (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ )
+ {
+ return split_on_first(str, delim.c_str());
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ std::pair<std::basic_string<charT,traits,alloc>, std::basic_string<charT,traits,alloc> >
+ split_on_last (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT," \n\r\t")
+ )
+ {
+ typename std::basic_string<charT,traits,alloc>::size_type delim_pos = str.find_last_of(delim);
+ if (delim_pos != std::basic_string<charT,traits,alloc>::npos)
+ return std::make_pair(str.substr(0, delim_pos), str.substr(delim_pos+1));
+ else
+ return std::make_pair(str, _dT(charT,""));
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ inline std::pair<std::basic_string<charT,traits,alloc>, std::basic_string<charT,traits,alloc> >
+ split_on_last (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ )
+ {
+ return split_on_last(str, delim.c_str());
+ }
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::vector<std::basic_string<charT,traits,alloc> > split (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT," \n\r\t")
+ )
+ {
+ std::basic_string<charT,traits,alloc> temp;
+
+ std::vector<std::basic_string<charT,traits,alloc> > res;
+
+ for (unsigned long i = 0; i < str.size(); ++i)
+ {
+ // check if delim contains the character str[i]
+ bool hit = false;
+ const charT* d = delim;
+ while (*d != '\0')
+ {
+ if (str[i] == *d)
+ {
+ hit = true;
+ break;
+ }
+ ++d;
+ }
+
+ if (hit)
+ {
+ if (temp.size() != 0)
+ {
+ res.push_back(temp);
+ temp.clear();
+ }
+ }
+ else
+ {
+ temp.push_back(str[i]);
+ }
+ }
+
+ if (temp.size() != 0)
+ res.push_back(temp);
+
+ return res;
+ }
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::vector<std::basic_string<charT,traits,alloc> > split (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ )
+ {
+ return split(str,delim.c_str());
+ }
+
+ inline const std::vector<std::string> split (
+ const char* str,
+ const char* delim = " \n\r\t"
+ )
+ {
+ return split(std::string(str),delim);
+ }
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_STRINg_
+
diff --git a/ml/dlib/dlib/string/string_abstract.h b/ml/dlib/dlib/string/string_abstract.h
new file mode 100644
index 000000000..0a1ef0c79
--- /dev/null
+++ b/ml/dlib/dlib/string/string_abstract.h
@@ -0,0 +1,652 @@
+// Copyright (C) 2006 Davis E. King (davis@dlib.net)
+// License: Boost Software License See LICENSE.txt for the full license.
+#undef DLIB_STRINg_ABSTRACT_
+#ifdef DLIB_STRINg_ABSTRACT_
+
+#include <string>
+#include <iostream>
+#include <vector>
+#include "../error.h"
+
+namespace dlib
+{
+
+// ----------------------------------------------------------------------------------------
+
+ class string_cast_error : public error
+ {
+ public:
+ string_cast_error():error(ECAST_TO_STRING) {}
+ };
+
+ template <
+ typename T,
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const T string_cast (
+ const std::basic_string<charT,traits,alloc>& str
+ );
+ /*!
+ requires
+ - T is not a pointer type
+ ensures
+ - returns str converted to T
+ throws
+ - string_cast_error
+ This exception is thrown if string_cast() is unable to convert
+ str into a T. Also, string_cast_error::info == str
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ class string_assign
+ {
+ /*!
+ WHAT THIS OBJECT REPRESENTS
+ This is a simple tool which provides an alternative syntax for using
+ the string_cast() function. It can be understood by considering
+ the following example:
+
+ string_assign sa;
+ int val;
+ double dval;
+
+ val = sa = "1234"; // executes: val = string_cast<int>("1234");
+ dval = sa = "3.141"; // executes: val = string_cast<double>("3.141");
+
+ After executing, val will be equal to 1234 and dval will be 3.141.
+ Note that you can use string_assign to assign to any type which you could
+ use with string_cast(), except for std::basic_string, assigning to this
+ type is ambiguous for boring technical reasons. But there isn't much
+ point in using this tool to assign from one string to another so it doesn't
+ matter.
+
+ Additionally, note that there is a global instance of this object, dlib::sa.
+ So you never have to create a string_assign object yourself. Finally, this
+ object is totally stateless and threadsafe.
+ !*/
+ };
+
+ const string_assign sa = string_assign();
+
+// ----------------------------------------------------------------------------------------
+
+ class cast_to_string_error : public error
+ {
+ public:
+ cast_to_string_error():error(ECAST_TO_STRING) {}
+ };
+
+ template <
+ typename T
+ >
+ const std::string cast_to_string (
+ const T& item
+ );
+ /*!
+ requires
+ - T is not a pointer type
+ ensures
+ - returns item converted to std::string
+ throws
+ - cast_to_string_error
+ This exception is thrown if cast_to_string() is unable to convert
+ item into a std::string.
+ !*/
+
+ template <
+ typename T
+ >
+ const std::wstring cast_to_wstring (
+ const T& item
+ );
+ /*!
+ requires
+ - T is not a pointer type
+ ensures
+ - returns item converted to std::wstring
+ throws
+ - cast_to_string_error
+ This exception is thrown if cast_to_string() is unable to convert
+ item into a std::string.
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ std::string pad_int_with_zeros (
+ int i,
+ unsigned long width = 6
+ );
+ /*!
+ ensures
+ - converts i into a string of at least width characters in length. If
+ necessary, the string will be padded with leading zeros to get
+ to width characters.
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::string narrow (
+ const std::basic_string<charT,traits,alloc>& str
+ );
+ /*!
+ ensures
+ - returns str as a std::string by converting every character in it to a char.
+ Note that any characters that do not have a mapping to type char will be
+ converted to a space.
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> wrap_string (
+ const std::basic_string<charT,traits,alloc>& str,
+ const unsigned long first_pad = 0,
+ const unsigned long rest_pad = 0,
+ const unsigned long max_per_line = 79
+ );
+ /*!
+ requires
+ - first_pad < max_per_line
+ - rest_pad < max_per_line
+ - rest_pad >= first_pad
+ ensures
+ - returns a copy of str S such that:
+ - S is broken up into lines separated by the \n character.
+ - The first line starts with first_pad space characters.
+ - The second and all subsequent lines start with rest_pad space characters.
+ - The first line is no longer than max_per_line - (rest_pad-first_pad) characters.
+ - The second and all subsequent lines are no longer than max_per_line characters.
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename traits
+ typename alloc
+ >
+ const std::basic_string<char,traits,alloc> tolower (
+ const std::basic_string<char,traits,alloc>& str
+ );
+ /*!
+ ensures
+ - returns a copy of str S such that:
+ - #S.size() == str.size()
+ - #S[i] == std::tolower(str[i])
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<char,traits,alloc> toupper (
+ const std::basic_string<char,traits,alloc>& str
+ );
+ /*!
+ ensures
+ - returns a copy of str S such that:
+ - #S.size() == str.size()
+ - #S[i] == std::toupper(str[i])
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ bool strings_equal_ignore_case (
+ const std::basic_string<char,traits,alloc>& str1,
+ const std::basic_string<char,traits,alloc>& str2
+ );
+ /*!
+ ensures
+ - returns tolower(str1) == tolower(str2)
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename traits,
+ typename alloc
+ >
+ bool strings_equal_ignore_case (
+ const std::basic_string<char,traits,alloc>& str1,
+ const std::basic_string<char,traits,alloc>& str2,
+ unsigned long num
+ );
+ /*!
+ ensures
+ - returns tolower(str1.substr(0,num)) == tolower(str2.substr(0,num))
+ (i.e. only compares the first num characters)
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> ltrim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& trim_chars
+ );
+ /*!
+ ensures
+ - returns a copy of str with any leading trim_chars
+ from the left side of the string removed.
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> ltrim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* trim_chars = _dT(charT," \t\r\n")
+ );
+ /*!
+ requires
+ - trim_chars == a valid null-terminated C string
+ ensures
+ - returns ltrim(str, std::basic_string<charT,traits,alloc>(trim_chars))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> rtrim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& trim_chars
+ );
+ /*!
+ ensures
+ - returns a copy of str with any trailing trim_chars
+ from the right side of the string removed.
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> rtrim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* trim_chars = _dT(charT," \t\r\n")
+ );
+ /*!
+ requires
+ - trim_chars == a valid null-terminated C string
+ ensures
+ - returns rtrim(str, std::basic_string<charT,traits,alloc>(trim_chars))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> trim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& trim_chars
+ );
+ /*!
+ ensures
+ - returns a copy of str with any leading or trailing trim_chars
+ from the ends of the string removed.
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> trim (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* trim_chars = _dT(charT," \t\r\n")
+ );
+ /*!
+ requires
+ - trim_chars == a valid null-terminated C string
+ ensures
+ - returns trim(str, std::basic_string<charT,traits,alloc>(trim_chars))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> rpad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const std::basic_string<charT,traits,alloc>& pad_string
+ );
+ /*!
+ ensures
+ - if (pad_length <= str.size()) then
+ - returns str
+ - else
+ - let P be a string defined as follows:
+ - P.size() == pad_length - str.size()
+ - P == (pad_string + pad_string + ... + pad_string).substr(0,pad_length - str.size())
+ (i.e. P == a string with the above specified size that contains just
+ repitions of the pad_string)
+ - returns the string str + P
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> rpad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const charT* pad_string = _dT(charT," ")
+ );
+ /*!
+ requires
+ - pad_string == a valid null-terminated C string
+ ensures
+ - returns rpad(str, pad_length, std::basic_string<charT,traits,alloc>(pad_string))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> lpad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const std::basic_string<charT,traits,alloc>& pad_string
+ );
+ /*!
+ ensures
+ - if (pad_length <= str.size()) then
+ - returns str
+ - else
+ - let P be a string defined as follows:
+ - P.size() == pad_length - str.size()
+ - P == (pad_string + pad_string + ... + pad_string).substr(0,pad_length - str.size())
+ (i.e. P == a string with the above specified size that contains just
+ repitions of the pad_string)
+ - returns the string P + str
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> lpad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const charT* pad_string = _dT(charT," ")
+ );
+ /*!
+ requires
+ - pad_string == a valid null-terminated C string
+ ensures
+ - returns lpad(str, pad_length, std::basic_string<charT,traits,alloc>(pad_string))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> pad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const std::basic_string<charT,traits,alloc>& pad_string
+ );
+ /*!
+ ensures
+ - let str_size == static_cast<long>(str.size())
+ - returns rpad( lpad(str, (pad_length-str_size)/2 + str_size, pad_string),
+ pad_length,
+ pad_string);
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> pad (
+ const std::basic_string<charT,traits,alloc>& str,
+ long pad_length,
+ const charT* pad_string = _dT(charT," ")
+ );
+ /*!
+ requires
+ - pad_string == a valid null-terminated C string
+ ensures
+ - returns pad(str, pad_length, std::basic_string<charT,traits,alloc>(pad_string))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> left_substr (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ );
+ /*!
+ ensures
+ - let delim_pos = str.find_first_of(delim)
+ - returns str.substr(0,delim_pos)
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> left_substr (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT," \n\r\t")
+ );
+ /*!
+ requires
+ - delim == a valid null-terminated C string
+ ensures
+ - returns left_substr(str, std::basic_string<charT,traits,alloc>(delim))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> right_substr (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ );
+ /*!
+ ensures
+ - let delim_pos = str.find_last_of(delim)
+ - if (delim_pos == std::string::npos) then
+ - returns ""
+ - else
+ - returns str.substr(delim_pos+1)
+ !*/
+
+ template <
+ typename charT,
+ typename traits
+ typename alloc
+ >
+ const std::basic_string<charT,traits,alloc> right_substr (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT," \n\r\t")
+ );
+ /*!
+ requires
+ - delim == a valid null-terminated C string
+ ensures
+ - returns right_substr(str, std::basic_string<charT,traits,alloc>(delim))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ std::pair<std::basic_string<charT,traits,alloc>, std::basic_string<charT,traits,alloc> >
+ split_on_first (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT, " \n\r\t")
+ );
+ /*!
+ ensures
+ - This function splits string into two parts, the split is based on the first
+ occurrence of any character from delim.
+ - let delim_pos = str.find_first_of(delim)
+ - if (delim_pos == std::string::npos) then
+ - returns make_pair(str,"")
+ - else
+ - return make_pair(str.substr(0, delim_pos), str.substr(delim_pos+1));
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ std::pair<std::basic_string<charT,traits,alloc>, std::basic_string<charT,traits,alloc> >
+ split_on_first (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ );
+ /*!
+ requires
+ - delim == a valid null-terminated C string
+ ensures
+ - returns split_on_first(str, delim.c_str())
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ std::pair<std::basic_string<charT,traits,alloc>, std::basic_string<charT,traits,alloc> >
+ split_on_last (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT, " \n\r\t")
+ );
+ /*!
+ ensures
+ - This function splits string into two parts, the split is based on the last
+ occurrence of any character from delim.
+ - let delim_pos = str.find_last_of(delim)
+ - if (delim_pos == std::string::npos) then
+ - returns make_pair(str,"")
+ - else
+ - return make_pair(str.substr(0, delim_pos), str.substr(delim_pos+1));
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ std::pair<std::basic_string<charT,traits,alloc>, std::basic_string<charT,traits,alloc> >
+ split_on_last (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ );
+ /*!
+ requires
+ - delim == a valid null-terminated C string
+ ensures
+ - returns split_on_last(str, delim.c_str())
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::vector<std::basic_string<charT,traits,alloc> > split (
+ const std::basic_string<charT,traits,alloc>& str,
+ const std::basic_string<charT,traits,alloc>& delim
+ );
+ /*!
+ ensures
+ - Breaks the given string str into a sequence of substrings delimited
+ by characters in delim and returns the results.
+ - returns a vector V such that:
+ - V.size() == the number of substrings found in str.
+ - for all i: V[i] == The ith substring. Note that it will not contain
+ any delimiter characters (i.e. characters in delim). It will also
+ never be an empty string.
+ - V contains the substrings in the order in which they appear in str.
+ That is, V[0] contains the first substring, V[1] the second, and
+ so on.
+ !*/
+
+ template <
+ typename charT,
+ typename traits,
+ typename alloc
+ >
+ const std::vector<std::basic_string<charT,traits,alloc> > split (
+ const std::basic_string<charT,traits,alloc>& str,
+ const charT* delim = _dT(charT," \n\r\t")
+ );
+ /*!
+ requires
+ - trim_chars == a valid null-terminated C string
+ ensures
+ - returns split(str, std::basic_string<charT,traits,alloc>(delim))
+ !*/
+
+// ----------------------------------------------------------------------------------------
+
+}
+
+#endif // DLIB_STRINg_ABSTRACT_
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-10 07:36:58 +0000