Menu
▾
▴
[xmlwrapp-commits] SF.net SVN: xmlwrapp:[222] trunk
|
From: <tbr...@us...> - 2012-03-20 16:50:12
|
Revision: 222
http://xmlwrapp.svn.sourceforge.net/xmlwrapp/?rev=222&view=rev
Author: tbrowder2
Date: 2012-03-20 16:49:59 +0000 (Tue, 20 Mar 2012)
Log Message:
-----------
change ustring to xmlwrappstring; change Glib namespace to xmlws namespace; remove glib headers; add utf8 headers
Modified Paths:
--------------
trunk/include/xmlwrappstring/xmlwrappstring.h
trunk/src/libxmlwrappstring/xmlwrappstring.cc
Modified: trunk/include/xmlwrappstring/xmlwrappstring.h
===================================================================
--- trunk/include/xmlwrappstring/xmlwrappstring.h 2012-03-20 16:18:57 UTC (rev 221)
+++ trunk/include/xmlwrappstring/xmlwrappstring.h 2012-03-20 16:49:59 UTC (rev 222)
@@ -20,10 +20,6 @@
#include "utf8.h"
-#include <glibmmconfig.h>
-#include <glibmm/unicode.h>
-#include <glib.h>
-
#include <iosfwd>
#include <iterator>
#include <sstream>
@@ -32,7 +28,7 @@
#include <cstddef> /* for ptrdiff_t */
#endif
-namespace Glib
+namespace xmlws
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -72,7 +68,7 @@
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-/** The iterator type of Glib::ustring.
+/** The iterator type of xmlws::xmlwrappstring.
* Note this is not a random access iterator but a bidirectional one,
* since all index operations need to iterate over the UTF-8 data. Use
* std::advance() to move to a certain position. However, all of the
@@ -85,7 +81,7 @@
* pointing into the same string.
*/
template <class T>
-class ustring_Iterator
+class xmlwrappstring_Iterator
{
public:
typedef std::bidirectional_iterator_tag iterator_category;
@@ -94,17 +90,17 @@
typedef value_type reference;
typedef void pointer;
- inline ustring_Iterator();
- inline ustring_Iterator(const ustring_Iterator<std::string::iterator>& other);
+ inline xmlwrappstring_Iterator();
+ inline xmlwrappstring_Iterator(const xmlwrappstring_Iterator<std::string::iterator>& other);
inline value_type operator*() const;
- inline ustring_Iterator<T> & operator++();
- inline const ustring_Iterator<T> operator++(int);
- inline ustring_Iterator<T> & operator--();
- inline const ustring_Iterator<T> operator--(int);
+ inline xmlwrappstring_Iterator<T> & operator++();
+ inline const xmlwrappstring_Iterator<T> operator++(int);
+ inline xmlwrappstring_Iterator<T> & operator--();
+ inline const xmlwrappstring_Iterator<T> operator--(int);
- explicit inline ustring_Iterator(T pos);
+ explicit inline xmlwrappstring_Iterator(T pos);
inline T base() const;
private:
@@ -118,25 +114,25 @@
* position, depending on the UTF-8 character width. You have to make
* sure the source contains at least one valid UTF-8 character.
*
- * This is mainly used by the implementation of Glib::ustring::iterator,
+ * This is mainly used by the implementation of xmlws::xmlwrappstring::iterator,
* but it might be useful as utility function if you prefer using
* std::string even for UTF-8 encoding.
*/
gunichar get_unichar_from_std_iterator(std::string::const_iterator pos) G_GNUC_PURE;
-/** Glib::ustring has much the same interface as std::string, but contains
+/** xmlws::xmlwrappstring has much the same interface as std::string, but contains
* %Unicode characters encoded as UTF-8.
*
* @par About UTF-8 and ASCII
* @par
* The standard character set ANSI_X3.4-1968 -- more commonly known as
* ASCII -- is a subset of UTF-8. So, if you want to, you can use
- * Glib::ustring without even thinking about UTF-8.
+ * xmlws::xmlwrappstring without even thinking about UTF-8.
* @par
* Whenever ASCII is mentioned in this manual, we mean the @em real ASCII
* (i.e. as defined in ANSI_X3.4-1968), which contains only 7-bit characters.
- * Glib::ustring can @em not be used with ASCII-compatible extended 8-bit
+ * xmlws::xmlwrappstring can @em not be used with ASCII-compatible extended 8-bit
* charsets like ISO-8859-1. It's a good idea to avoid string literals
* containing non-ASCII characters (e.g. German umlauts) in source code,
* or at least you should use UTF-8 literals.
@@ -144,12 +140,12 @@
* You can find a detailed UTF-8 and %Unicode FAQ here:
* http://www.cl.cam.ac.uk/~mgk25/unicode.html
*
- * @par Glib::ustring vs. std::string
+ * @par xmlws::xmlwrappstring vs. std::string
* @par
- * Glib::ustring has implicit type conversions to and from std::string.
+ * xmlws::xmlwrappstring has implicit type conversions to and from std::string.
* These conversions do @em not convert to/from the current locale (see
- * Glib::locale_from_utf8() and Glib::locale_to_utf8() if you need that). You
- * can always use std::string instead of Glib::ustring -- however, using
+ * xmlws::locale_from_utf8() and xmlws::locale_to_utf8() if you need that). You
+ * can always use std::string instead of xmlws::xmlwrappstring -- however, using
* std::string with multi-byte characters is quite hard. For instance,
* <tt>std::string::operator[]</tt> might return a byte in the middle of a
* character, and <tt>std::string::length()</tt> returns the number of bytes
@@ -160,12 +156,12 @@
* that std::wstring is not a UTF-8 string class because it contains only
* fixed-width characters (where width could be 32, 16, or even 8 bits).
*
- * @par Glib::ustring and stream input/output
+ * @par xmlws::xmlwrappstring and stream input/output
* @par
* The stream I/O operators, that is operator<<() and operator>>(), perform
* implicit charset conversion to/from the current locale. If that's not
* what you intented (e.g. when writing to a configuration file that should
- * always be UTF-8 encoded) use ustring::raw() to override this behaviour.
+ * always be UTF-8 encoded) use xmlwrappstring::raw() to override this behaviour.
* @par
* If you're using std::ostringstream to build strings for display in the
* user interface, you must convert the result back to UTF-8 as shown below:
@@ -173,31 +169,31 @@
* std::ostringstream output;
* output.imbue(std::locale("")); // use the user's locale for this stream
* output << percentage << " % done";
- * label->set_text(Glib::locale_to_utf8(output.str()));
+ * label->set_text(xmlws::locale_to_utf8(output.str()));
* @endcode
*
* @par Formatted output and internationalization
* @par
- * The methods ustring::compose() and ustring::format() provide a convenient
+ * The methods xmlwrappstring::compose() and xmlwrappstring::format() provide a convenient
* and powerful alternative to string streams, as shown in the example below.
* Refer to the method documentation of compose() and format() for details.
* @code
- * using Glib::ustring;
+ * using xmlws::xmlwrappstring;
*
- * ustring message = ustring::compose("%1 is lower than 0x%2.",
- * 12, ustring::format(std::hex, 16));
+ * xmlwrappstring message = xmlwrappstring::compose("%1 is lower than 0x%2.",
+ * 12, xmlwrappstring::format(std::hex, 16));
* @endcode
*
* @par Implementation notes
* @par
- * Glib::ustring does not inherit from std::string, because std::string was
+ * xmlws::xmlwrappstring does not inherit from std::string, because std::string was
* intended to be a final class. For instance, it does not have a virtual
* destructor. Also, a HAS-A relationship is more appropriate because
- * ustring can't just enhance the std::string interface. Rather, it has to
+ * xmlwrappstring can't just enhance the std::string interface. Rather, it has to
* reimplement the interface so that all operations are based on characters
* instead of bytes.
*/
-class ustring
+class xmlwrappstring
{
public:
typedef std::string::size_type size_type;
@@ -207,8 +203,8 @@
typedef gunichar & reference;
typedef const gunichar & const_reference;
- typedef ustring_Iterator<std::string::iterator> iterator;
- typedef ustring_Iterator<std::string::const_iterator> const_iterator;
+ typedef xmlwrappstring_Iterator<std::string::iterator> iterator;
+ typedef xmlwrappstring_Iterator<std::string::const_iterator> const_iterator;
#ifndef GLIBMM_HAVE_SUN_REVERSE_ITERATOR
@@ -242,112 +238,112 @@
/*! Default constructor, which creates an empty string.
*/
- ustring();
+ xmlwrappstring();
- ~ustring();
+ ~xmlwrappstring();
- /*! Construct a ustring as a copy of another ustring.
+ /*! Construct a xmlwrappstring as a copy of another xmlwrappstring.
* @param other A source string.
*/
- ustring(const ustring& other);
+ xmlwrappstring(const xmlwrappstring& other);
/*! Assign the value of another string to this string.
* @param other A source string.
*/
- ustring& operator=(const ustring& other);
+ xmlwrappstring& operator=(const xmlwrappstring& other);
/*! Swap contents with another string.
* @param other String to swap with.
*/
- void swap(ustring& other);
+ void swap(xmlwrappstring& other);
- /*! Construct a ustring as a copy of another std::string.
+ /*! Construct a xmlwrappstring as a copy of another std::string.
* @param src A source <tt>std::string</tt> containing text encoded as UTF-8.
*/
- ustring(const std::string& src);
+ xmlwrappstring(const std::string& src);
- /*! Construct a ustring as a copy of a substring.
- * @param src %Source ustring.
+ /*! Construct a xmlwrappstring as a copy of a substring.
+ * @param src %Source xmlwrappstring.
* @param i Index of first character to copy from.
* @param n Number of UTF-8 characters to copy (defaults to copying the remainder).
*/
- ustring(const ustring& src, size_type i, size_type n=npos);
+ xmlwrappstring(const xmlwrappstring& src, size_type i, size_type n=npos);
- /*! Construct a ustring as a partial copy of a C string.
+ /*! Construct a xmlwrappstring as a partial copy of a C string.
* @param src %Source C string encoded as UTF-8.
* @param n Number of UTF-8 characters to copy.
*/
- ustring(const char* src, size_type n);
+ xmlwrappstring(const char* src, size_type n);
- /*! Construct a ustring as a copy of a C string.
+ /*! Construct a xmlwrappstring as a copy of a C string.
* @param src %Source C string encoded as UTF-8.
*/
- ustring(const char* src);
+ xmlwrappstring(const char* src);
- /*! Construct a ustring as multiple characters.
+ /*! Construct a xmlwrappstring as multiple characters.
* @param n Number of characters.
* @param uc UCS-4 code point to use.
*/
- ustring(size_type n, gunichar uc);
+ xmlwrappstring(size_type n, gunichar uc);
- /*! Construct a ustring as multiple characters.
+ /*! Construct a xmlwrappstring as multiple characters.
* @param n Number of characters.
* @param c ASCII character to use.
*/
- ustring(size_type n, char c);
+ xmlwrappstring(size_type n, char c);
- /*! Construct a ustring as a copy of a range.
+ /*! Construct a xmlwrappstring as a copy of a range.
* @param pbegin Start of range.
* @param pend End of range.
*/
- template <class In> ustring(In pbegin, In pend);
+ template <class In> xmlwrappstring(In pbegin, In pend);
//! @name Assign new contents.
//! @{
- ustring& operator=(const std::string& src);
- ustring& operator=(const char* src);
- ustring& operator=(gunichar uc);
- ustring& operator=(char c);
+ xmlwrappstring& operator=(const std::string& src);
+ xmlwrappstring& operator=(const char* src);
+ xmlwrappstring& operator=(gunichar uc);
+ xmlwrappstring& operator=(char c);
- ustring& assign(const ustring& src);
- ustring& assign(const ustring& src, size_type i, size_type n);
- ustring& assign(const char* src, size_type n);
- ustring& assign(const char* src);
- ustring& assign(size_type n, gunichar uc);
- ustring& assign(size_type n, char c);
- template <class In> ustring& assign(In pbegin, In pend);
+ xmlwrappstring& assign(const xmlwrappstring& src);
+ xmlwrappstring& assign(const xmlwrappstring& src, size_type i, size_type n);
+ xmlwrappstring& assign(const char* src, size_type n);
+ xmlwrappstring& assign(const char* src);
+ xmlwrappstring& assign(size_type n, gunichar uc);
+ xmlwrappstring& assign(size_type n, char c);
+ template <class In> xmlwrappstring& assign(In pbegin, In pend);
//! @}
//! @name Append to the string.
//! @{
- ustring& operator+=(const ustring& src);
- ustring& operator+=(const char* src);
- ustring& operator+=(gunichar uc);
- ustring& operator+=(char c);
+ xmlwrappstring& operator+=(const xmlwrappstring& src);
+ xmlwrappstring& operator+=(const char* src);
+ xmlwrappstring& operator+=(gunichar uc);
+ xmlwrappstring& operator+=(char c);
void push_back(gunichar uc);
void push_back(char c);
- ustring& append(const ustring& src);
- ustring& append(const ustring& src, size_type i, size_type n);
- ustring& append(const char* src, size_type n);
- ustring& append(const char* src);
- ustring& append(size_type n, gunichar uc);
- ustring& append(size_type n, char c);
- template <class In> ustring& append(In pbegin, In pend);
+ xmlwrappstring& append(const xmlwrappstring& src);
+ xmlwrappstring& append(const xmlwrappstring& src, size_type i, size_type n);
+ xmlwrappstring& append(const char* src, size_type n);
+ xmlwrappstring& append(const char* src);
+ xmlwrappstring& append(size_type n, gunichar uc);
+ xmlwrappstring& append(size_type n, char c);
+ template <class In> xmlwrappstring& append(In pbegin, In pend);
//! @}
//! @name Insert into the string.
//! @{
- ustring& insert(size_type i, const ustring& src);
- ustring& insert(size_type i, const ustring& src, size_type i2, size_type n);
- ustring& insert(size_type i, const char* src, size_type n);
- ustring& insert(size_type i, const char* src);
- ustring& insert(size_type i, size_type n, gunichar uc);
- ustring& insert(size_type i, size_type n, char c);
+ xmlwrappstring& insert(size_type i, const xmlwrappstring& src);
+ xmlwrappstring& insert(size_type i, const xmlwrappstring& src, size_type i2, size_type n);
+ xmlwrappstring& insert(size_type i, const char* src, size_type n);
+ xmlwrappstring& insert(size_type i, const char* src);
+ xmlwrappstring& insert(size_type i, size_type n, gunichar uc);
+ xmlwrappstring& insert(size_type i, size_type n, char c);
iterator insert(iterator p, gunichar uc);
iterator insert(iterator p, char c);
@@ -359,27 +355,27 @@
//! @name Replace sub-strings.
//! @{
- ustring& replace(size_type i, size_type n, const ustring& src);
- ustring& replace(size_type i, size_type n, const ustring& src, size_type i2, size_type n2);
- ustring& replace(size_type i, size_type n, const char* src, size_type n2);
- ustring& replace(size_type i, size_type n, const char* src);
- ustring& replace(size_type i, size_type n, size_type n2, gunichar uc);
- ustring& replace(size_type i, size_type n, size_type n2, char c);
+ xmlwrappstring& replace(size_type i, size_type n, const xmlwrappstring& src);
+ xmlwrappstring& replace(size_type i, size_type n, const xmlwrappstring& src, size_type i2, size_type n2);
+ xmlwrappstring& replace(size_type i, size_type n, const char* src, size_type n2);
+ xmlwrappstring& replace(size_type i, size_type n, const char* src);
+ xmlwrappstring& replace(size_type i, size_type n, size_type n2, gunichar uc);
+ xmlwrappstring& replace(size_type i, size_type n, size_type n2, char c);
- ustring& replace(iterator pbegin, iterator pend, const ustring& src);
- ustring& replace(iterator pbegin, iterator pend, const char* src, size_type n);
- ustring& replace(iterator pbegin, iterator pend, const char* src);
- ustring& replace(iterator pbegin, iterator pend, size_type n, gunichar uc);
- ustring& replace(iterator pbegin, iterator pend, size_type n, char c);
- template <class In> ustring& replace(iterator pbegin, iterator pend, In pbegin2, In pend2);
+ xmlwrappstring& replace(iterator pbegin, iterator pend, const xmlwrappstring& src);
+ xmlwrappstring& replace(iterator pbegin, iterator pend, const char* src, size_type n);
+ xmlwrappstring& replace(iterator pbegin, iterator pend, const char* src);
+ xmlwrappstring& replace(iterator pbegin, iterator pend, size_type n, gunichar uc);
+ xmlwrappstring& replace(iterator pbegin, iterator pend, size_type n, char c);
+ template <class In> xmlwrappstring& replace(iterator pbegin, iterator pend, In pbegin2, In pend2);
//! @}
//! @name Erase sub-strings.
//! @{
void clear();
- ustring& erase(size_type i, size_type n=npos);
- ustring& erase();
+ xmlwrappstring& erase(size_type i, size_type n=npos);
+ xmlwrappstring& erase();
iterator erase(iterator p);
iterator erase(iterator pbegin, iterator pend);
@@ -387,10 +383,10 @@
//! @name Compare and collate.
//! @{
- int compare(const ustring& rhs) const;
+ int compare(const xmlwrappstring& rhs) const;
int compare(const char* rhs) const;
- int compare(size_type i, size_type n, const ustring& rhs) const;
- int compare(size_type i, size_type n, const ustring& rhs, size_type i2, size_type n2) const;
+ int compare(size_type i, size_type n, const xmlwrappstring& rhs) const;
+ int compare(size_type i, size_type n, const xmlwrappstring& rhs, size_type i2, size_type n2) const;
int compare(size_type i, size_type n, const char* rhs, size_type n2) const;
int compare(size_type i, size_type n, const char* rhs) const;
@@ -399,11 +395,11 @@
* <tt>std::set<></tt>, you should consider creating a collate key first
* and compare this key instead of the actual string.
*
- * The ustring::compare() methods as well as the relational operators
+ * The xmlwrappstring::compare() methods as well as the relational operators
* <tt>== != < > <= >=</tt> are quite costly
* because they have to deal with %Unicode and the collation rules defined by
* the current locale. Converting both operands to UCS-4 is just the first
- * of several costly steps involved when comparing ustrings. So be careful.
+ * of several costly steps involved when comparing xmlwrappstrings. So be careful.
*/
std::string collate_key() const;
@@ -424,7 +420,7 @@
/*! No reference return; use replace() to write characters. @throw std::out_of_range */
value_type at(size_type i) const;
- inline ustring substr(size_type i=0, size_type n=npos) const;
+ inline xmlwrappstring substr(size_type i=0, size_type n=npos) const;
//! @}
//! @name Access a sequence of characters.
@@ -443,13 +439,13 @@
//! @name Find sub-strings.
//! @{
- size_type find(const ustring& str, size_type i=0) const;
+ size_type find(const xmlwrappstring& str, size_type i=0) const;
size_type find(const char* str, size_type i, size_type n) const;
size_type find(const char* str, size_type i=0) const;
size_type find(gunichar uc, size_type i=0) const;
size_type find(char c, size_type i=0) const;
- size_type rfind(const ustring& str, size_type i=npos) const;
+ size_type rfind(const xmlwrappstring& str, size_type i=npos) const;
size_type rfind(const char* str, size_type i, size_type n) const;
size_type rfind(const char* str, size_type i=npos) const;
size_type rfind(gunichar uc, size_type i=npos) const;
@@ -459,25 +455,25 @@
//! @name Match against a set of characters.
//! @{
- size_type find_first_of(const ustring& match, size_type i=0) const;
+ size_type find_first_of(const xmlwrappstring& match, size_type i=0) const;
size_type find_first_of(const char* match, size_type i, size_type n) const;
size_type find_first_of(const char* match, size_type i=0) const;
size_type find_first_of(gunichar uc, size_type i=0) const;
size_type find_first_of(char c, size_type i=0) const;
- size_type find_last_of(const ustring& match, size_type i=npos) const;
+ size_type find_last_of(const xmlwrappstring& match, size_type i=npos) const;
size_type find_last_of(const char* match, size_type i, size_type n) const;
size_type find_last_of(const char* match, size_type i=npos) const;
size_type find_last_of(gunichar uc, size_type i=npos) const;
size_type find_last_of(char c, size_type i=npos) const;
- size_type find_first_not_of(const ustring& match, size_type i=0) const;
+ size_type find_first_not_of(const xmlwrappstring& match, size_type i=0) const;
size_type find_first_not_of(const char* match, size_type i, size_type n) const;
size_type find_first_not_of(const char* match, size_type i=0) const;
size_type find_first_not_of(gunichar uc, size_type i=0) const;
size_type find_first_not_of(char c, size_type i=0) const;
- size_type find_last_not_of(const ustring& match, size_type i=npos) const;
+ size_type find_last_not_of(const xmlwrappstring& match, size_type i=npos) const;
size_type find_last_not_of(const char* match, size_type i, size_type n) const;
size_type find_last_not_of(const char* match, size_type i=npos) const;
size_type find_last_not_of(gunichar uc, size_type i=npos) const;
@@ -531,7 +527,7 @@
//! @name Get a per-byte representation of the string.
//! @{
- inline operator std::string() const; // e.g. std::string str = ustring();
+ inline operator std::string() const; // e.g. std::string str = xmlwrappstring();
inline const std::string& raw() const;
// Not necessarily an ASCII char*. Use g_utf8_*() where necessary.
@@ -555,7 +551,7 @@
bool validate(const_iterator& first_invalid) const;
/*! Check whether the string is plain 7-bit ASCII. @par
- * Unlike any other ustring method, is_ascii() is safe to use on invalid
+ * Unlike any other xmlwrappstring method, is_ascii() is safe to use on invalid
* UTF-8 strings. If the string isn't valid UTF-8, it cannot be valid
* ASCII either, therefore is_ascii() will just return @c false then.
* @return Whether the string contains only ASCII characters.
@@ -563,7 +559,7 @@
bool is_ascii() const;
/*! "Normalize" the %Unicode character representation of the string. */
- ustring normalize(NormalizeMode mode = NORMALIZE_DEFAULT_COMPOSE) const;
+ xmlwrappstring normalize(NormalizeMode mode = NORMALIZE_DEFAULT_COMPOSE) const;
//! @}
//! @name Character case conversion.
@@ -576,21 +572,21 @@
* <tt>"ß"</tt> will be replaced by two characters
* <tt>"SS"</tt> because there is no capital <tt>"ß"</tt>.
*/
- ustring uppercase() const;
+ xmlwrappstring uppercase() const;
/*! Returns a new UTF-8 string with all characters characters converted to
* their lowercase equivalent, while honoring the current locale. The
* resulting string may change in the number of bytes as well as in the
* number of characters.
*/
- ustring lowercase() const;
+ xmlwrappstring lowercase() const;
/*! Returns a caseless representation of the UTF-8 string. The resulting
* string doesn't correspond to any particular case, therefore the result
* is only useful to compare strings and should never be displayed to the
* user.
*/
- ustring casefold() const;
+ xmlwrappstring casefold() const;
//! @}
//! @name Message formatting.
@@ -601,7 +597,7 @@
*/
template <class T1>
static inline
- ustring compose(const ustring& fmt);
+ xmlwrappstring compose(const xmlwrappstring& fmt);
/*! Substitute placeholders in a format string with the referenced arguments.
* The template string should be in <tt>qt-format</tt>, that is
@@ -610,91 +606,91 @@
* reordered.
* @par Example:
* @code
- * using Glib::ustring;
+ * using xmlws::xmlwrappstring;
* const int percentage = 50;
- * const ustring text = ustring::compose("%1%% done", percentage);
+ * const xmlwrappstring text = xmlwrappstring::compose("%1%% done", percentage);
* @endcode
* @param fmt A template string in <tt>qt-format</tt>.
* @param a1 The argument to substitute for <tt>"%1"</tt>.
* @return The substituted message string.
- * @throw Glib::ConvertError
+ * @throw xmlws::ConvertError
*
* @newin{2,16}
*/
template <class T1>
static inline
- ustring compose(const ustring& fmt, const T1& a1);
+ xmlwrappstring compose(const xmlwrappstring& fmt, const T1& a1);
- /* See the documentation for compose(const ustring& fmt, const T1& a1).
+ /* See the documentation for compose(const xmlwrappstring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2>
static inline
- ustring compose(const ustring& fmt, const T1& a1, const T2& a2);
+ xmlwrappstring compose(const xmlwrappstring& fmt, const T1& a1, const T2& a2);
- /* See the documentation for compose(const ustring& fmt, const T1& a1).
+ /* See the documentation for compose(const xmlwrappstring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3>
static inline
- ustring compose(const ustring& fmt,
+ xmlwrappstring compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3);
- /* See the documentation for compose(const ustring& fmt, const T1& a1).
+ /* See the documentation for compose(const xmlwrappstring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4>
static inline
- ustring compose(const ustring& fmt,
+ xmlwrappstring compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4);
- /* See the documentation for compose(const ustring& fmt, const T1& a1).
+ /* See the documentation for compose(const xmlwrappstring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5>
static inline
- ustring compose(const ustring& fmt,
+ xmlwrappstring compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5);
- /* See the documentation for compose(const ustring& fmt, const T1& a1).
+ /* See the documentation for compose(const xmlwrappstring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5, class T6>
static inline
- ustring compose(const ustring& fmt,
+ xmlwrappstring compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6);
- /* See the documentation for compose(const ustring& fmt, const T1& a1).
+ /* See the documentation for compose(const xmlwrappstring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
static inline
- ustring compose(const ustring& fmt,
+ xmlwrappstring compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6,
const T7& a7);
- /* See the documentation for compose(const ustring& fmt, const T1& a1).
+ /* See the documentation for compose(const xmlwrappstring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8>
static inline
- ustring compose(const ustring& fmt,
+ xmlwrappstring compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6,
const T7& a7, const T8& a8);
- /* See the documentation for compose(const ustring& fmt, const T1& a1).
+ /* See the documentation for compose(const xmlwrappstring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5,
class T6, class T7, class T8, class T9>
static inline
- ustring compose(const ustring& fmt,
+ xmlwrappstring compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6,
const T7& a7, const T8& a8, const T9& a9);
@@ -707,9 +703,9 @@
* in conjunction with compose() to facilitate localization of user-visible
* messages.
* @code
- * using Glib::ustring;
+ * using xmlws::xmlwrappstring;
* double value = 22.0 / 7.0;
- * ustring text = ustring::format(std::fixed, std::setprecision(2), value);
+ * xmlwrappstring text = xmlwrappstring::format(std::fixed, std::setprecision(2), value);
* @endcode
* @note The use of a wide character stream in the implementation of format()
* is almost completely transparent. However, one of the instances where the
@@ -718,20 +714,20 @@
* must be of type <tt>wchar_t</tt>. This can be achieved by using the
* <tt>L</tt> prefix with a character literal, as shown in the example.
* @code
- * using Glib::ustring;
+ * using xmlws::xmlwrappstring;
* // Insert leading zeroes to fill in at least six digits
- * ustring text = ustring::format(std::setfill(L'0'), std::setw(6), 123);
+ * xmlwrappstring text = xmlwrappstring::format(std::setfill(L'0'), std::setw(6), 123);
* @endcode
*
* @param a1 A streamable value or an I/O manipulator.
* @return The string representation of the argument stream.
- * @throw Glib::ConvertError
+ * @throw xmlws::ConvertError
*
* @newin{2,16}
*/
template <class T1>
static inline
- ustring format(const T1& a1);
+ xmlwrappstring format(const T1& a1);
/* See the documentation for format(const T1& a1).
*
@@ -739,7 +735,7 @@
*/
template <class T1, class T2>
static inline
- ustring format(const T1& a1, const T2& a2);
+ xmlwrappstring format(const T1& a1, const T2& a2);
/* See the documentation for format(const T1& a1).
*
@@ -747,7 +743,7 @@
*/
template <class T1, class T2, class T3>
static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3);
+ xmlwrappstring format(const T1& a1, const T2& a2, const T3& a3);
/* See the documentation for format(const T1& a1).
*
@@ -755,7 +751,7 @@
*/
template <class T1, class T2, class T3, class T4>
static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4);
+ xmlwrappstring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4);
/* See the documentation for format(const T1& a1).
*
@@ -763,7 +759,7 @@
*/
template <class T1, class T2, class T3, class T4, class T5>
static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3,
+ xmlwrappstring format(const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5);
/* See the documentation for format(const T1& a1).
@@ -772,7 +768,7 @@
*/
template <class T1, class T2, class T3, class T4, class T5, class T6>
static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3,
+ xmlwrappstring format(const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6);
/* See the documentation for format(const T1& a1).
@@ -782,7 +778,7 @@
template <class T1, class T2, class T3, class T4,
class T5, class T6, class T7>
static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
+ xmlwrappstring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
const T5& a5, const T6& a6, const T7& a7);
/* See the documentation for format(const T1& a1).
@@ -792,7 +788,7 @@
template <class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8>
static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
+ xmlwrappstring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
const T5& a5, const T6& a6, const T7& a7, const T8& a8);
//! @}
@@ -803,7 +799,7 @@
#ifdef GLIBMM_HAVE_STD_ITERATOR_TRAITS
template <class In, class ValueType = typename std::iterator_traits<In>::value_type>
#else
- template <class In, class ValueType = typename Glib::IteratorTraits<In>::value_type>
+ template <class In, class ValueType = typename xmlws::IteratorTraits<In>::value_type>
#endif
struct SequenceToString;
@@ -815,7 +811,7 @@
template <class T> class Stringify;
class FormatStream;
- static ustring compose_argv(const ustring& fmt, int argc, const ustring* const* argv);
+ static xmlwrappstring compose_argv(const xmlwrappstring& fmt, int argc, const xmlwrappstring* const* argv);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
@@ -826,34 +822,34 @@
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <class In, class ValueType>
-struct ustring::SequenceToString
+struct xmlwrappstring::SequenceToString
{};
template <class In>
-struct ustring::SequenceToString<In, char> : public std::string
+struct xmlwrappstring::SequenceToString<In, char> : public std::string
{
SequenceToString(In pbegin, In pend);
};
template <class In>
-struct ustring::SequenceToString<In, gunichar> : public std::string
+struct xmlwrappstring::SequenceToString<In, gunichar> : public std::string
{
SequenceToString(In pbegin, In pend);
};
template <>
-struct ustring::SequenceToString<Glib::ustring::iterator, gunichar> : public std::string
+struct xmlwrappstring::SequenceToString<xmlws::xmlwrappstring::iterator, gunichar> : public std::string
{
- SequenceToString(Glib::ustring::iterator pbegin, Glib::ustring::iterator pend);
+ SequenceToString(xmlws::xmlwrappstring::iterator pbegin, xmlws::xmlwrappstring::iterator pend);
};
template <>
-struct ustring::SequenceToString<Glib::ustring::const_iterator, gunichar> : public std::string
+struct xmlwrappstring::SequenceToString<xmlws::xmlwrappstring::const_iterator, gunichar> : public std::string
{
- SequenceToString(Glib::ustring::const_iterator pbegin, Glib::ustring::const_iterator pend);
+ SequenceToString(xmlws::xmlwrappstring::const_iterator pbegin, xmlws::xmlwrappstring::const_iterator pend);
};
-class ustring::FormatStream
+class xmlwrappstring::FormatStream
{
private:
#ifdef GLIBMM_HAVE_WIDE_STREAM
@@ -864,8 +860,8 @@
StreamType stream_;
// noncopyable
- FormatStream(const ustring::FormatStream&);
- FormatStream& operator=(const ustring::FormatStream&);
+ FormatStream(const xmlwrappstring::FormatStream&);
+ FormatStream& operator=(const xmlwrappstring::FormatStream&);
public:
FormatStream();
@@ -878,37 +874,37 @@
//This overload exists to avoid the templated stream() being called for non-const char*.
inline void stream(char* value);
- ustring to_string() const;
+ xmlwrappstring to_string() const;
};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
/** Stream input operator.
- * @relates Glib::ustring
- * @throw Glib::ConvertError
+ * @relates xmlws::xmlwrappstring
+ * @throw xmlws::ConvertError
*/
-std::istream& operator>>(std::istream& is, Glib::ustring& utf8_string);
+std::istream& operator>>(std::istream& is, xmlws::xmlwrappstring& utf8_string);
/** Stream output operator.
- * @relates Glib::ustring
- * @throw Glib::ConvertError
+ * @relates xmlws::xmlwrappstring
+ * @throw xmlws::ConvertError
*/
-std::ostream& operator<<(std::ostream& os, const Glib::ustring& utf8_string);
+std::ostream& operator<<(std::ostream& os, const xmlws::xmlwrappstring& utf8_string);
#ifdef GLIBMM_HAVE_WIDE_STREAM
/** Wide stream input operator.
- * @relates Glib::ustring
- * @throw Glib::ConvertError
+ * @relates xmlws::xmlwrappstring
+ * @throw xmlws::ConvertError
*/
-std::wistream& operator>>(std::wistream& is, ustring& utf8_string);
+std::wistream& operator>>(std::wistream& is, xmlwrappstring& utf8_string);
/** Wide stream output operator.
- * @relates Glib::ustring
- * @throw Glib::ConvertError
+ * @relates xmlws::xmlwrappstring
+ * @throw xmlws::ConvertError
*/
-std::wostream& operator<<(std::wostream& os, const ustring& utf8_string);
+std::wostream& operator<<(std::wostream& os, const xmlwrappstring& utf8_string);
#endif /* GLIBMM_HAVE_WIDE_STREAM */
@@ -918,64 +914,64 @@
#ifndef DOXYGEN_SHOULD_SKIP_THIS
-/**** Glib::ustring_Iterator<> *********************************************/
+/**** xmlws::xmlwrappstring_Iterator<> *********************************************/
template <class T> inline
-ustring_Iterator<T>::ustring_Iterator(T pos)
+xmlwrappstring_Iterator<T>::xmlwrappstring_Iterator(T pos)
:
pos_ (pos)
{}
template <class T> inline
-T ustring_Iterator<T>::base() const
+T xmlwrappstring_Iterator<T>::base() const
{
return pos_;
}
template <class T> inline
-ustring_Iterator<T>::ustring_Iterator()
+xmlwrappstring_Iterator<T>::xmlwrappstring_Iterator()
:
pos_ ()
{}
template <class T> inline
-ustring_Iterator<T>::ustring_Iterator(const ustring_Iterator<std::string::iterator>& other)
+xmlwrappstring_Iterator<T>::xmlwrappstring_Iterator(const xmlwrappstring_Iterator<std::string::iterator>& other)
:
pos_ (other.base())
{}
template <class T> inline
-typename ustring_Iterator<T>::value_type ustring_Iterator<T>::operator*() const
+typename xmlwrappstring_Iterator<T>::value_type xmlwrappstring_Iterator<T>::operator*() const
{
- return Glib::get_unichar_from_std_iterator(pos_);
+ return xmlws::get_unichar_from_std_iterator(pos_);
}
template <class T> inline
-ustring_Iterator<T>& ustring_Iterator<T>::operator++()
+xmlwrappstring_Iterator<T>& xmlwrappstring_Iterator<T>::operator++()
{
pos_ += g_utf8_skip[static_cast<unsigned char>(*pos_)];
return *this;
}
template <class T> inline
-const ustring_Iterator<T> ustring_Iterator<T>::operator++(int)
+const xmlwrappstring_Iterator<T> xmlwrappstring_Iterator<T>::operator++(int)
{
- const ustring_Iterator<T> temp (*this);
+ const xmlwrappstring_Iterator<T> temp (*this);
this->operator++();
return temp;
}
template <class T> inline
-ustring_Iterator<T>& ustring_Iterator<T>::operator--()
+xmlwrappstring_Iterator<T>& xmlwrappstring_Iterator<T>::operator--()
{
do --pos_; while((static_cast<unsigned char>(*pos_) & 0xC0u) == 0x80);
return *this;
}
template <class T> inline
-const ustring_Iterator<T> ustring_Iterator<T>::operator--(int)
+const xmlwrappstring_Iterator<T> xmlwrappstring_Iterator<T>::operator--(int)
{
- const ustring_Iterator<T> temp (*this);
+ const xmlwrappstring_Iterator<T> temp (*this);
this->operator--();
return temp;
}
@@ -983,44 +979,44 @@
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-/** @relates Glib::ustring_Iterator */
+/** @relates xmlws::xmlwrappstring_Iterator */
inline
-bool operator==(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+bool operator==(const xmlws::xmlwrappstring::const_iterator& lhs, const xmlws::xmlwrappstring::const_iterator& rhs)
{
return (lhs.base() == rhs.base());
}
-/** @relates Glib::ustring_Iterator */
+/** @relates xmlws::xmlwrappstring_Iterator */
inline
-bool operator!=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+bool operator!=(const xmlws::xmlwrappstring::const_iterator& lhs, const xmlws::xmlwrappstring::const_iterator& rhs)
{
return (lhs.base() != rhs.base());
}
-/** @relates Glib::ustring_Iterator */
+/** @relates xmlws::xmlwrappstring_Iterator */
inline
-bool operator<(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+bool operator<(const xmlws::xmlwrappstring::const_iterator& lhs, const xmlws::xmlwrappstring::const_iterator& rhs)
{
return (lhs.base() < rhs.base());
}
-/** @relates Glib::ustring_Iterator */
+/** @relates xmlws::xmlwrappstring_Iterator */
inline
-bool operator>(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+bool operator>(const xmlws::xmlwrappstring::const_iterator& lhs, const xmlws::xmlwrappstring::const_iterator& rhs)
{
return (lhs.base() > rhs.base());
}
-/** @relates Glib::ustring_Iterator */
+/** @relates xmlws::xmlwrappstring_Iterator */
inline
-bool operator<=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+bool operator<=(const xmlws::xmlwrappstring::const_iterator& lhs, const xmlws::xmlwrappstring::const_iterator& rhs)
{
return (lhs.base() <= rhs.base());
}
-/** @relates Glib::ustring_Iterator */
+/** @relates xmlws::xmlwrappstring_Iterator */
inline
-bool operator>=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+bool operator>=(const xmlws::xmlwrappstring::const_iterator& lhs, const xmlws::xmlwrappstring::const_iterator& rhs)
{
return (lhs.base() >= rhs.base());
}
@@ -1028,16 +1024,16 @@
#ifndef DOXYGEN_SHOULD_SKIP_THIS
-/**** Glib::ustring::SequenceToString **************************************/
+/**** xmlws::xmlwrappstring::SequenceToString **************************************/
template <class In>
-ustring::SequenceToString<In,char>::SequenceToString(In pbegin, In pend)
+xmlwrappstring::SequenceToString<In,char>::SequenceToString(In pbegin, In pend)
:
std::string(pbegin, pend)
{}
template <class In>
-ustring::SequenceToString<In,gunichar>::SequenceToString(In pbegin, In pend)
+xmlwrappstring::SequenceToString<In,gunichar>::SequenceToString(In pbegin, In pend)
{
char utf8_buf[6]; // stores a single UTF-8 character
@@ -1048,99 +1044,99 @@
}
}
-/**** Glib::ustring::FormatStream ******************************************/
+/**** xmlws::xmlwrappstring::FormatStream ******************************************/
template <class T> inline
-void ustring::FormatStream::stream(const T& value)
+void xmlwrappstring::FormatStream::stream(const T& value)
{
stream_ << value;
}
inline
-void ustring::FormatStream::stream(const char* value)
+void xmlwrappstring::FormatStream::stream(const char* value)
{
- stream_ << ustring(value);
+ stream_ << xmlwrappstring(value);
}
inline
-void ustring::FormatStream::stream(char* value)
+void xmlwrappstring::FormatStream::stream(char* value)
{
- stream_ << ustring(value);
+ stream_ << xmlwrappstring(value);
}
-/**** Glib::ustring ********************************************************/
+/**** xmlws::xmlwrappstring ********************************************************/
template <class In>
-ustring::ustring(In pbegin, In pend)
+xmlwrappstring::xmlwrappstring(In pbegin, In pend)
:
- string_ (Glib::ustring::SequenceToString<In>(pbegin, pend))
+ string_ (xmlws::xmlwrappstring::SequenceToString<In>(pbegin, pend))
{}
template <class In>
-ustring& ustring::assign(In pbegin, In pend)
+xmlwrappstring& xmlwrappstring::assign(In pbegin, In pend)
{
- Glib::ustring::SequenceToString<In> temp_string (pbegin, pend);
+ xmlws::xmlwrappstring::SequenceToString<In> temp_string (pbegin, pend);
string_.swap(temp_string); // constant-time operation
return *this;
}
template <class In>
-ustring& ustring::append(In pbegin, In pend)
+xmlwrappstring& xmlwrappstring::append(In pbegin, In pend)
{
- string_.append(Glib::ustring::SequenceToString<In>(pbegin, pend));
+ string_.append(xmlws::xmlwrappstring::SequenceToString<In>(pbegin, pend));
return *this;
}
template <class In>
-void ustring::insert(ustring::iterator p, In pbegin, In pend)
+void xmlwrappstring::insert(xmlwrappstring::iterator p, In pbegin, In pend)
{
- string_.insert(p.base(), Glib::ustring::SequenceToString<In>(pbegin, pend));
+ string_.insert(p.base(), xmlws::xmlwrappstring::SequenceToString<In>(pbegin, pend));
}
template <class In>
-ustring& ustring::replace(ustring::iterator pbegin, ustring::iterator pend, In pbegin2, In pend2)
+xmlwrappstring& xmlwrappstring::replace(xmlwrappstring::iterator pbegin, xmlwrappstring::iterator pend, In pbegin2, In pend2)
{
string_.replace(
pbegin.base(), pend.base(),
- Glib::ustring::SequenceToString<In>(pbegin2, pend2));
+ xmlws::xmlwrappstring::SequenceToString<In>(pbegin2, pend2));
return *this;
}
-// The ustring methods substr() and operator std::string() are inline,
+// The xmlwrappstring methods substr() and operator std::string() are inline,
// so that the compiler has a fair chance to optimize the copy ctor away.
inline
-ustring ustring::substr(ustring::size_type i, ustring::size_type n) const
+xmlwrappstring xmlwrappstring::substr(xmlwrappstring::size_type i, xmlwrappstring::size_type n) const
{
- return ustring(*this, i, n);
+ return xmlwrappstring(*this, i, n);
}
inline
-ustring::operator std::string() const
+xmlwrappstring::operator std::string() const
{
return string_;
}
inline
-const std::string& ustring::raw() const
+const std::string& xmlwrappstring::raw() const
{
return string_;
}
template <class T1>
inline // static
-ustring ustring::format(const T1& a1)
+xmlwrappstring xmlwrappstring::format(const T1& a1)
{
- ustring::FormatStream buf;
+ xmlwrappstring::FormatStream buf;
buf.stream(a1);
return buf.to_string();
}
template <class T1, class T2>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2)
+xmlwrappstring xmlwrappstring::format(const T1& a1, const T2& a2)
{
- ustring::FormatStream buf;
+ xmlwrappstring::FormatStream buf;
buf.stream(a1);
buf.stream(a2);
return buf.to_string();
@@ -1148,9 +1144,9 @@
template <class T1, class T2, class T3>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3)
+xmlwrappstring xmlwrappstring::format(const T1& a1, const T2& a2, const T3& a3)
{
- ustring::FormatStream buf;
+ xmlwrappstring::FormatStream buf;
buf.stream(a1);
buf.stream(a2);
buf.stream(a3);
@@ -1159,9 +1155,9 @@
template <class T1, class T2, class T3, class T4>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4)
+xmlwrappstring xmlwrappstring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4)
{
- ustring::FormatStream buf;
+ xmlwrappstring::FormatStream buf;
buf.stream(a1);
buf.stream(a2);
buf.stream(a3);
@@ -1171,10 +1167,10 @@
template <class T1, class T2, class T3, class T4, class T5>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3,
+xmlwrappstring xmlwrappstring::format(const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5)
{
- ustring::FormatStream buf;
+ xmlwrappstring::FormatStream buf;
buf.stream(a1);
buf.stream(a2);
buf.stream(a3);
@@ -1185,10 +1181,10 @@
template <class T1, class T2, class T3, class T4, class T5, class T6>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3,
+xmlwrappstring xmlwrappstring::format(const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6)
{
- ustring::FormatStream buf;
+ xmlwrappstring::FormatStream buf;
buf.stream(a1);
buf.stream(a2);
buf.stream(a3);
@@ -1201,10 +1197,10 @@
template <class T1, class T2, class T3, class T4,
class T5, class T6, class T7>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
+xmlwrappstring xmlwrappstring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
const T5& a5, const T6& a6, const T7& a7)
{
- ustring::FormatStream buf;
+ xmlwrappstring::FormatStream buf;
buf.stream(a1);
buf.stream(a2);
buf.stream(a3);
@@ -1218,10 +1214,10 @@
template <class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
+xmlwrappstring xmlwrappstring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
const T5& a5, const T6& a6, const T7& a7, const T8& a8)
{
- ustring::FormatStream buf;
+ xmlwrappstring::FormatStream buf;
buf.stream(a1);
buf.stream(a2);
buf.stream(a3);
@@ -1233,382 +1229,382 @@
return buf.to_string();
}
-/** An inner class used by ustring.
+/** An inner class used by xmlwrappstring.
*/
template <class T>
-class ustring::Stringify
+class xmlwrappstring::Stringify
{
private:
- ustring string_;
+ xmlwrappstring string_;
// noncopyable
- Stringify(const ustring::Stringify<T>&);
- Stringify<T>& operator=(const ustring::Stringify<T>&);
+ Stringify(const xmlwrappstring::Stringify<T>&);
+ Stringify<T>& operator=(const xmlwrappstring::Stringify<T>&);
public:
- explicit inline Stringify(const T& arg) : string_ (ustring::format(arg)) {}
+ explicit inline Stringify(const T& arg) : string_ (xmlwrappstring::format(arg)) {}
//TODO: Why is this here? See the template specialization:
explicit inline Stringify(const char* arg) : string_(arg) {}
- inline const ustring* ptr() const { return &string_; }
+ inline const xmlwrappstring* ptr() const { return &string_; }
};
-/// A template specialization for Stringify<ustring>:
+/// A template specialization for Stringify<xmlwrappstring>:
template <>
-class ustring::Stringify<ustring>
+class xmlwrappstring::Stringify<xmlwrappstring>
{
private:
- const ustring& string_;
+ const xmlwrappstring& string_;
// noncopyable
- Stringify(const ustring::Stringify<ustring>&);
- Stringify<ustring>& operator=(const ustring::Stringify<ustring>&);
+ Stringify(const xmlwrappstring::Stringify<xmlwrappstring>&);
+ Stringify<xmlwrappstring>& operator=(const xmlwrappstring::Stringify<xmlwrappstring>&);
public:
- explicit inline Stringify(const ustring& arg) : string_(arg) {}
- inline const ustring* ptr() const { return &string_; }
+ explicit inline Stringify(const xmlwrappstring& arg) : string_(arg) {}
+ inline const xmlwrappstring* ptr() const { return &string_; }
};
/** A template specialization for Stringify<const char*>,
* because the regular template has ambiguous constructor overloads for char*.
*/
template <>
-class ustring::Stringify<const char*>
+class xmlwrappstring::Stringify<const char*>
{
private:
- const ustring string_;
+ const xmlwrappstring string_;
// noncopyable
- Stringify(const ustring::Stringify<const char*>&);
- Stringify<ustring>& operator=(const ustring::Stringify<const char*>&);
+ Stringify(const xmlwrappstring::Stringify<const char*>&);
+ Stringify<xmlwrappstring>& operator=(const xmlwrappstring::Stringify<const char*>&);
public:
explicit inline Stringify(const char* arg) : string_(arg) {}
- inline const ustring* ptr() const { return &string_; }
+ inline const xmlwrappstring* ptr() const { return &string_; }
};
/** A template specialization for Stringify<char[N]> (for string literals),
* because the regular template has ambiguous constructor overloads for char*.
*/
template <std::size_t N>
-class ustring::Stringify<char[N]>
+class xmlwrappstring::Stringify<char[N]>
{
private:
- const ustring string_;
+ const xmlwrappstring string_;
// noncopyable
- Stringify(const ustring::Stringify<char[N]>&);
- Stringify<ustring>& operator=(const ustring::Stringify<char[N]>&);
+ Stringify(const xmlwrappstring::Stringify<char[N]>&);
+ Stringify<xmlwrappstring>& operator=(const xmlwrappstring::Stringify<char[N]>&);
public:
explicit inline Stringify(const char arg[N]) : string_(arg) {}
- inline const ustring* ptr() const { return &string_; }
+ inline const xmlwrappstring* ptr() const { return &string_; }
};
template <class T1>
inline // static
-ustring ustring::compose(const ustring& fmt)
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt)
{
- return ustring::compose_argv(fmt, 0, 0);
+ return xmlwrappstring::compose_argv(fmt, 0, 0);
}
template <class T1>
inline // static
-ustring ustring::compose(const ustring& fmt, const T1& a1)
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt, const T1& a1)
{
- const ustring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T1> s1(a1);
- const ustring *const argv[] = { s1.ptr() };
- return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
+ const xmlwrappstring *const argv[] = { s1.ptr() };
+ return xmlwrappstring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2>
inline // static
-ustring ustring::compose(const ustring& fmt, const T1& a1, const T2& a2)
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt, const T1& a1, const T2& a2)
{
- const ustring::Stringify<T1> s1(a1);
- const ustring::Stringify<T2> s2(a2);
+ const xmlwrappstring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T2> s2(a2);
- const ustring *const argv[] = { s1.ptr(), s2.ptr() };
- return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
+ const xmlwrappstring *const argv[] = { s1.ptr(), s2.ptr() };
+ return xmlwrappstring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3>
inline // static
-ustring ustring::compose(const ustring& fmt,
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3)
{
- const ustring::Stringify<T1> s1(a1);
- const ustring::Stringify<T2> s2(a2);
- const ustring::Stringify<T3> s3(a3);
+ const xmlwrappstring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T2> s2(a2);
+ const xmlwrappstring::Stringify<T3> s3(a3);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr() };
- return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
+ const xmlwrappstring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr() };
+ return xmlwrappstring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4>
inline // static
-ustring ustring::compose(const ustring& fmt,
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3, const T4& a4)
{
- const ustring::Stringify<T1> s1(a1);
- const ustring::Stringify<T2> s2(a2);
- const ustring::Stringify<T3> s3(a3);
- const ustring::Stringify<T4> s4(a4);
+ const xmlwrappstring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T2> s2(a2);
+ const xmlwrappstring::Stringify<T3> s3(a3);
+ const xmlwrappstring::Stringify<T4> s4(a4);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr() };
- return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
+ const xmlwrappstring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr() };
+ return xmlwrappstring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4, class T5>
inline // static
-ustring ustring::compose(const ustring& fmt,
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5)
{
- const ustring::Stringify<T1> s1(a1);
- const ustring::Stringify<T2> s2(a2);
- const ustring::Stringify<T3> s3(a3);
- const ustring::Stringify<T4> s4(a4);
- const ustring::Stringify<T5> s5(a5);
+ const xmlwrappstring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T2> s2(a2);
+ const xmlwrappstring::Stringify<T3> s3(a3);
+ const xmlwrappstring::Stringify<T4> s4(a4);
+ const xmlwrappstring::Stringify<T5> s5(a5);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(), s5.ptr() };
- return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
+ const xmlwrappstring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(), s5.ptr() };
+ return xmlwrappstring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
inline // static
-ustring ustring::compose(const ustring& fmt,
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6)
{
- const ustring::Stringify<T1> s1(a1);
- const ustring::Stringify<T2> s2(a2);
- const ustring::Stringify<T3> s3(a3);
- const ustring::Stringify<T4> s4(a4);
- const ustring::Stringify<T5> s5(a5);
- const ustring::Stringify<T6> s6(a6);
+ const xmlwrappstring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T2> s2(a2);
+ const xmlwrappstring::Stringify<T3> s3(a3);
+ const xmlwrappstring::Stringify<T4> s4(a4);
+ const xmlwrappstring::Stringify<T5> s5(a5);
+ const xmlwrappstring::Stringify<T6> s6(a6);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
+ const xmlwrappstring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
s5.ptr(), s6.ptr() };
- return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
+ return xmlwrappstring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
inline // static
-ustring ustring::compose(const ustring& fmt,
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6, const T7& a7)
{
- const ustring::Stringify<T1> s1(a1);
- const ustring::Stringify<T2> s2(a2);
- const ustring::Stringify<T3> s3(a3);
- const ustring::Stringify<T4> s4(a4);
- const ustring::Stringify<T5> s5(a5);
- const ustring::Stringify<T6> s6(a6);
- const ustring::Stringify<T7> s7(a7);
+ const xmlwrappstring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T2> s2(a2);
+ const xmlwrappstring::Stringify<T3> s3(a3);
+ const xmlwrappstring::Stringify<T4> s4(a4);
+ const xmlwrappstring::Stringify<T5> s5(a5);
+ const xmlwrappstring::Stringify<T6> s6(a6);
+ const xmlwrappstring::Stringify<T7> s7(a7);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
+ const xmlwrappstring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
s5.ptr(), s6.ptr(), s7.ptr() };
- return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
+ return xmlwrappstring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8>
inline // static
-ustring ustring::compose(const ustring& fmt,
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6,
const T7& a7, const T8& a8)
{
- const ustring::Stringify<T1> s1(a1);
- const ustring::Stringify<T2> s2(a2);
- const ustring::Stringify<T3> s3(a3);
- const ustring::Stringify<T4> s4(a4);
- const ustring::Stringify<T5> s5(a5);
- const ustring::Stringify<T6> s6(a6);
- const ustring::Stringify<T7> s7(a7);
- const ustring::Stringify<T8> s8(a8);
+ const xmlwrappstring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T2> s2(a2);
+ const xmlwrappstring::Stringify<T3> s3(a3);
+ const xmlwrappstring::Stringify<T4> s4(a4);
+ const xmlwrappstring::Stringify<T5> s5(a5);
+ const xmlwrappstring::Stringify<T6> s6(a6);
+ const xmlwrappstring::Stringify<T7> s7(a7);
+ const xmlwrappstring::Stringify<T8> s8(a8);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
+ const xmlwrappstring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
s5.ptr(), s6.ptr(), s7.ptr(), s8.ptr() };
- return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
+ return xmlwrappstring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4, class T5,
class T6, class T7, class T8, class T9>
inline // static
-ustring ustring::compose(const ustring& fmt,
+xmlwrappstring xmlwrappstring::compose(const xmlwrappstring& fmt,
const T1& a1, const T2& a2, const T3& a3,
const T4& a4, const T5& a5, const T6& a6,
const T7& a7, const T8& a8, const T9& a9)
{
- const ustring::Stringify<T1> s1(a1);
- const ustring::Stringify<T2> s2(a2);
- const ustring::Stringify<T3> s3(a3);
- const ustring::Stringify<T4> s4(a4);
- const ustring::Stringify<T5> s5(a5);
- const ustring::Stringify<T6> s6(a6);
- const ustring::Stringify<T7> s7(a7);
- const ustring::Stringify<T8> s8(a8);
- const ustring::Stringify<T9> s9(a9);
+ const xmlwrappstring::Stringify<T1> s1(a1);
+ const xmlwrappstring::Stringify<T2> s2(a2);
+ const xmlwrappstring::Stringify<T3> s3(a3);
+ const xmlwrappstring::Stringify<T4> s4(a4);
+ ...
[truncated message content] |
