Introduce wide streams. This fixes the remaining problems of plain text

[lyx.git] / src / support / lstrings.h

diff --git a/src/support/lstrings.h b/src/support/lstrings.h
index 0ef0806edd97c22c2d0289457d6425b24864b1c9..2f61aaa8f4b1ed8b743c5af5e8b582c028e21372 100644 (file)
--- a/src/support/lstrings.h
+++ b/src/support/lstrings.h
@@ -16,8 +16,9 @@
 #ifndef LSTRINGS_H
 #define LSTRINGS_H
 
+#include "support/docstring.h"
+
 #include <vector>
-#include <string>
 
 
 namespace lyx {
@@ -25,10 +26,14 @@ namespace support {
 
 ///
 int compare_no_case(std::string const & s, std::string const & s2);
+int compare_no_case(lyx::docstring const & s, lyx::docstring const & s2);
 
 ///
 int compare_ascii_no_case(std::string const & s, std::string const & s2);
 
+///
+int compare_ascii_no_case(docstring const & s, docstring const & s2);
+
 ///
 int compare_no_case(std::string const & s, std::string const & s2, unsigned int len);
 
@@ -69,6 +74,12 @@ char lowercase(char c);
 ///
 char uppercase(char c);
 
+/// changes the case only if c is a one-byte char
+char_type lowercase(char_type c);
+
+/// changes the case only if c is a one-byte char
+char_type uppercase(char_type c);
+
 /// same as lowercase(), but ignores locale
 std::string const ascii_lowercase(std::string const &);
 
@@ -94,6 +105,12 @@ bool contains(std::string const & a, B b)
        return a.find(b) != std::string::npos;
 }
 
+template <typename B>
+bool contains(lyx::docstring const & a, B b)
+{
+       return a.find(b) != lyx::docstring::npos;
+}
+
 ///
 bool containsOnly(std::string const &, std::string const &);
 
@@ -107,6 +124,8 @@ bool containsOnly(std::string const &, std::string const &);
 */
 std::string const token(std::string const & a, char delim, int n);
 
+lyx::docstring const token(lyx::docstring const & a,
+                          lyx::char_type delim, int n);
 
 /** Search a token in this string using the delim.
     Doesn't modify the original string. Returns -1 in case of
@@ -123,10 +142,25 @@ int tokenPos(std::string const & a, char delim, std::string const & tok);
 /// Substitute all \a oldchar with \a newchar
 std::string const subst(std::string const & a, char oldchar, char newchar);
 
+/// Substitute all \a oldchar with \a newchar
+lyx::docstring const subst(docstring const & a,
+                                                  lyx::char_type oldchar, lyx::char_type newchar);
+
 /// substitutes all instances of \a oldstr with \a newstr
 std::string const subst(std::string const & a,
                   std::string const & oldstr, std::string const & newstr);
 
+/// substitutes all instances of \a oldstr with \a newstr
+lyx::docstring const subst(lyx::docstring const & a,
+               lyx::docstring const & oldstr, lyx::docstring const & newstr);
+
+/** Trims characters off the end and beginning of a string.
+    \code
+    trim("ccabccc", "c") == "ab".
+    \endcode
+*/
+lyx::docstring const trim(lyx::docstring const & a, char const * p = " ");
+
 /** Trims characters off the end and beginning of a string.
     \code
     trim("ccabccc", "c") == "ab".
@@ -158,6 +192,7 @@ std::string const ltrim(std::string const & a, char const * p = " ");
     \endcode
 */
 std::string const split(std::string const & a, std::string & piece, char delim);
+docstring const split(docstring const & a, docstring & piece, char_type delim);
 
 /// Same as split but does not return a piece
 std::string const split(std::string const & a, char delim);
@@ -180,51 +215,57 @@ std::string const getStringFromVector(std::vector<std::string> const & vec,
 /// found, else -1. The last item in \p str must be "".
 int findToken(char const * const str[], std::string const & search_token);
 
+/// Convert internal line endings to line endings as expected by the OS
+lyx::docstring const externalLineEnding(lyx::docstring const & str);
+
+/// Convert line endings in any formnat to internal line endings
+lyx::docstring const internalLineEnding(lyx::docstring const & str);
+
 
 #ifdef I_AM_NOT_AFRAID_OF_HEADER_LIBRARIES
 
 #include <boost/format.hpp>
 
 template<class Arg1>
-string bformat(string const & fmt, Arg1 arg1)
+lyx::docstring bformat(lyx::docstring const & fmt, Arg1 arg1)
 {
-       return (boost::format(fmt) % arg1).str();
+       return (boost::basic_format<char_type>(fmt) % arg1).str();
 }
 
 
 template<class Arg1, class Arg2>
-string bformat(string const & fmt, Arg1 arg1, Arg2 arg2)
+lyx::docstring bformat(lyx::docstring const & fmt, Arg1 arg1, Arg2 arg2)
 {
-       return (boost::format(fmt) % arg1 % arg2).str();
+       return (boost::basic_format<char_type>(fmt) % arg1 % arg2).str();
 }
 
 
 template<class Arg1, class Arg2, class Arg3>
-string bformat(string const & fmt, Arg1 arg1, Arg2 arg2, Arg3 arg3)
+lyx::docstring bformat(lyx::docstring const & fmt, Arg1 arg1, Arg2 arg2, Arg3 arg3)
 {
-       return (boost::format(fmt) % arg1 % arg2 % arg3).str();
+       return (boost::basic_format<char_type>(fmt) % arg1 % arg2 % arg3).str();
 }
 
 
 template<class Arg1, class Arg2, class Arg3, class Arg4>
-string bformat(string const & fmt, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
+lyx::docstring bformat(lyx::docstring const & fmt, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
 {
-       return (boost::format(fmt) % arg1 % arg2 % arg3 % arg4).str();
+       return (boost::basic_format<char_type>(fmt) % arg1 % arg2 % arg3 % arg4).str();
 }
 
 #else
 
 template <class Arg1>
-std::string bformat(std::string const & fmt, Arg1);
+lyx::docstring bformat(lyx::docstring const & fmt, Arg1);
 
 template <class Arg1, class Arg2>
-std::string bformat(std::string const & fmt, Arg1, Arg2);
+lyx::docstring bformat(lyx::docstring const & fmt, Arg1, Arg2);
 
 template <class Arg1, class Arg2, class Arg3>
-std::string bformat(std::string const & fmt, Arg1, Arg2, Arg3);
+lyx::docstring bformat(lyx::docstring const & fmt, Arg1, Arg2, Arg3);
 
 template <class Arg1, class Arg2, class Arg3, class Arg4>
-std::string bformat(std::string const & fmt, Arg1, Arg2, Arg3, Arg4);
+lyx::docstring bformat(lyx::docstring const & fmt, Arg1, Arg2, Arg3, Arg4);
 
 #endif