Index: mythtv/libs/libmyth/libmyth.pro
===================================================================
--- mythtv/libs/libmyth/libmyth.pro	(revision 19128)
+++ mythtv/libs/libmyth/libmyth.pro	(working copy)
@@ -27,7 +27,7 @@
 HEADERS += volumebase.h virtualkeyboard.h visual.h xmlparse.h
 HEADERS += mythhdd.h mythcdrom.h storagegroup.h dbutil.h
 HEADERS += mythcommandlineparser.h mythterminal.h
-HEADERS += mythhttppool.h mythhttphandler.h
+HEADERS += mythhttppool.h mythhttphandler.h mstring.h
 
 SOURCES += audiooutput.cpp audiooutputbase.cpp audiooutputnull.cpp
 SOURCES += audiooutputdigitalencoder.cpp audiosettings.cpp
@@ -44,7 +44,7 @@
 SOURCES += volumebase.cpp virtualkeyboard.cpp xmlparse.cpp
 SOURCES += mythhdd.cpp mythcdrom.cpp storagegroup.cpp dbutil.cpp
 SOURCES += mythcommandlineparser.cpp mythterminal.cpp
-SOURCES += mythhttppool.cpp mythhttphandler.cpp
+SOURCES += mythhttppool.cpp mythhttphandler.cpp mstring.cpp
 
 
 INCLUDEPATH += ../libmythsamplerate ../libmythsoundtouch ../libmythfreesurround
Index: mythtv/libs/libmyth/mstring.h
===================================================================
--- mythtv/libs/libmyth/mstring.h	(revision 0)
+++ mythtv/libs/libmyth/mstring.h	(revision 0)
@@ -0,0 +1,362 @@
+/*
+ *  Class MString: a thread-safe version of QString
+ *
+ *  Copyright (C) 2008 Jerome Brock <jpbrock@users.sourceforge.net>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef MSTRING_H
+#define MSTRING_H
+
+#include <QtCore/QString>
+#include <QtCore/QReadWriteLock>
+
+#include "mythexp.h"
+
+class MPUBLIC MString
+{
+private:
+    mutable QReadWriteLock m_lock;
+    QString m_string;
+
+public:
+    MString() {};
+    MString(const QChar * unicode, int size) {m_string = QString(unicode, size);};
+    MString(int size, QChar ch) {m_string = QString(size, ch);};
+    MString(const MString & other) {m_string = other.toQString();};
+    MString(const QString & other) {m_string = QString(other);};
+    MString(const char * str) {m_string = QString(str);};
+    MString(const QByteArray & ba) {m_string = QString(ba);};
+    ~MString() {};
+
+
+    static const MString null;
+    enum NormalizationForm {
+            NormalizationForm_D, 
+            NormalizationForm_C, 
+            NormalizationForm_KD, 
+            NormalizationForm_KC
+    };
+    enum SectionFlag {
+            SectionDefault             = 0x00,
+            SectionSkipEmpty           = 0x01,
+            SectionIncludeLeadingSep   = 0x02,
+            SectionIncludeTrailingSep  = 0x04,
+            SectionCaseInsensitiveSeps = 0x08,
+    };
+    Q_DECLARE_FLAGS(SectionFlags, SectionFlag)
+    
+    enum SplitBehavior {KeepEmptyParts, SkipEmptyParts};
+
+
+    MString & append(const MString & str);
+    MString & append(const QLatin1String & str);
+    MString & append(const QByteArray & ba);
+    MString & append(const char * str);
+    MString & append(QChar ch);
+    MString arg(const MString & a, int fieldWidth = 0, 
+                    const QChar & fillChar = QLatin1Char(' ')) const;
+    MString arg(const MString & a1, const MString & a2) const;
+    MString arg(const MString & a1, const MString & a2, const MString & a3) const;
+    MString arg(const MString & a1, const MString & a2, const MString & a3, 
+                    const MString & a4) const;
+    MString arg(const MString & a1, const MString & a2, const MString & a3, 
+                    const MString & a4, const MString & a5) const;
+    MString arg(const MString & a1, const MString & a2, const MString & a3, 
+                    const MString & a4, const MString & a5, 
+                    const MString & a6) const;
+    MString arg(const MString & a1, const MString & a2, const MString & a3, 
+                    const MString & a4, const MString & a5, 
+                    const MString & a6, const MString & a7) const;
+    MString arg(const MString & a1, const MString & a2, const MString & a3, 
+                    const MString & a4, const MString & a5, 
+                    const MString & a6, const MString & a7, 
+                    const MString & a8) const;
+    MString arg(const MString & a1, const MString & a2, const MString & a3, 
+                    const MString & a4, const MString & a5, 
+                    const MString & a6, const MString & a7, 
+                    const MString & a8, const MString & a9) const;
+    const QChar at(int position) const;
+    int capacity() const;
+    void chop(int n);
+    void clear();
+    int compare(const MString & other) const;
+    int compare(const MString & other, Qt::CaseSensitivity cs) const;
+    int compare(const QLatin1String & other, 
+                    Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    const QChar * constData() const;
+    bool contains(const MString & str, 
+                    Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool contains(const QRegExp & rx) const;
+    int count(const MString & str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(const QRegExp & rx) const;
+    int count() const;
+    //QChar * data ();
+    //const QChar * data () const;
+    bool endsWith(const MString & s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QLatin1String & s, 
+                    Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QChar & c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    MString & fill(QChar ch, int size = -1);
+    int indexOf(const MString & str, int from = 0, 
+                    Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(QChar ch, int from = 0, 
+                    Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QRegExp & rx, int from = 0) const;
+    MString & insert(int position, const MString & str);
+    MString & insert(int position, const QLatin1String & str);
+    MString & insert(int position, const QChar * unicode, int size);
+    MString & insert(int position, QChar ch);
+    bool isEmpty() const;
+    bool isNull() const;
+    int lastIndexOf(const MString & str, int from = -1, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(QChar ch, int from = -1, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QRegExp & rx, int from = -1) const;
+    MString left(int n) const;
+    MString leftJustified(int width, QChar fill = QLatin1Char(' '), 
+                            bool truncate = false) const;
+    int length() const;
+    int localeAwareCompare(const MString & other) const;
+    MString mid(int position, int n = -1) const;
+    MString normalized(QString::NormalizationForm mode) const;
+    MString normalized(QString::NormalizationForm mode, 
+                            QChar::UnicodeVersion version) const;
+    MString & prepend(const MString & str);
+    MString & prepend(const QLatin1String & str);
+    MString & prepend(const QByteArray & ba);
+    MString & prepend(const char * str);
+    MString & prepend(QChar ch);
+    void push_back(const MString & other) {append(other);};
+    void push_back(QChar ch) {append(ch);};
+    void push_front(const MString & other) {prepend(other);};
+    void push_front(QChar ch) {prepend(ch);};
+    MString & remove(int position, int n);
+    MString & remove(const MString & str, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    MString & remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    MString & remove(const QRegExp & rx);
+    MString & replace(int position, int n, const MString & after);
+    MString & replace(int position, int n, const QChar * unicode, int size);
+    MString & replace(int position, int n, QChar after);
+    MString & replace(const MString & before, const MString & after, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    MString & replace(QChar ch, const MString & after, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    MString & replace(QChar before, QChar after, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    MString & replace(const QRegExp & rx, const MString & after);
+    void reserve(int size);
+    void resize(int size);
+    MString right(int n) const;
+    MString rightJustified(int width, QChar fill = QLatin1Char(' '), 
+                                bool truncate = false) const;
+    MString section(QChar sep, int start, int end = -1, 
+                        SectionFlags flags = SectionDefault) const;
+    MString section(const MString & sep, int start, int end = -1, 
+                        SectionFlags flags = SectionDefault) const;
+    MString section(const QRegExp & reg, int start, int end = -1, 
+                        SectionFlags flags = SectionDefault) const;
+    MString & setNum(uint n, int base = 10);
+    MString & setNum(long n, int base = 10);
+    MString & setNum(ulong n, int base = 10);
+    MString & setNum(qlonglong n, int base = 10);
+    MString & setNum(qulonglong n, int base = 10);
+    MString & setNum(short n, int base = 10);
+    MString & setNum(ushort n, int base = 10);
+    MString & setNum(double n, char format = 'g', int precision = 6);
+    MString & setNum(float n, char format = 'g', int precision = 6);
+    MString & setUnicode(const QChar * unicode, int size);
+    MString & setUtf16(const ushort * unicode, int size);
+    MString simplified() const;
+    int size() const;
+    QStringList split(const MString & sep, 
+                        SplitBehavior behavior = KeepEmptyParts, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    QStringList split(const QChar & sep, 
+                        SplitBehavior behavior = KeepEmptyParts, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    QStringList split(const QRegExp & rx, 
+                        SplitBehavior behavior = KeepEmptyParts) const;
+    //MString & sprintf ( const char * cformat, ... );
+    void squeeze();
+    bool startsWith(const MString & s, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QLatin1String & s, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QChar & c, 
+                        Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    QByteArray toAscii() const;
+    MString toCaseFolded() const;
+    double toDouble(bool * ok = 0) const;
+    float toFloat(bool * ok = 0) const;
+    int toInt(bool * ok = 0, int base = 10) const;
+    QByteArray toLatin1() const;
+    QByteArray toLocal8Bit() const;
+    long toLong(bool * ok = 0, int base = 10) const;
+    qlonglong toLongLong(bool * ok = 0, int base = 10) const;
+    MString toLower() const;
+    QString toQString() const;
+    short toShort(bool * ok = 0, int base = 10) const;
+    std::string toStdString() const;
+    std::wstring toStdWString() const;
+    uint toUInt(bool * ok = 0, int base = 10) const;
+    ulong toULong(bool * ok = 0, int base = 10) const;
+    qulonglong toULongLong(bool * ok = 0, int base = 10) const;
+    ushort toUShort(bool * ok = 0, int base = 10) const;
+    QVector<uint> toUcs4() const;
+    MString toUpper() const;
+    QByteArray toUtf8() const;
+    int toWCharArray(wchar_t * array) const;
+    MString trimmed() const;
+    void truncate(int position);
+    const QChar * unicode() const;
+    MString & vsprintf(const char * cformat, va_list ap);
+
+    bool operator== (const MString & other) const;
+    bool operator== (const QLatin1String & other) const;
+    bool operator== (const QByteArray & other) const;
+    bool operator== (const char * other) const;
+
+    bool operator!= (const MString & other) const {return !(*this == other);};
+    bool operator!= (const QLatin1String & other) const {return !(*this == other);};
+    bool operator!= (const QByteArray & other) const {return !(*this == other);};
+    bool operator!= (const char * other) const {return !(*this == other);};
+
+    bool operator< (const MString & other) const;
+    bool operator< (const QLatin1String & other) const;
+    bool operator< (const QByteArray & other) const;
+    bool operator< (const char * other) const;
+
+    bool operator<= (const MString & other) const;
+    bool operator<= (const QLatin1String & other) const;
+    bool operator<= (const QByteArray & other) const;
+    bool operator<= (const char * other) const;
+
+    bool operator> (const MString & other) const {return !(*this <= other);};
+    bool operator> (const QLatin1String & other) const {return !(*this <= other);};
+    bool operator> (const QByteArray & other) const {return !(*this <= other);};
+    bool operator> (const char * other) const {return !(*this <= other);};
+
+    bool operator>= (const MString & other) const {return !(*this < other);};
+    bool operator>= (const QLatin1String & other) const {return !(*this < other);};
+    bool operator>= (const QByteArray & other) const {return !(*this < other);};
+    bool operator>= (const char * other) const {return !(*this < other);};
+
+    MString & operator= (const MString & other);
+    MString & operator= (const QLatin1String & str);
+    MString & operator= (const QByteArray & ba);
+    MString & operator= (const char * str);
+    MString & operator= (char ch);
+    MString & operator= (QChar ch);
+
+    MString & operator+= (const MString & other) {return append(other);};
+    MString & operator+= (const QLatin1String & str) {return append(str);};
+    MString & operator+= (const QByteArray & ba) {return append(ba);};
+    MString & operator+= (const char * str) {return append(str);};
+    MString & operator+= (char ch) {return append(ch);};
+    MString & operator+= (QChar ch) {return append(ch);};
+
+    //QCharRef operator[] ( int position );
+    const QChar operator[](int position) const;
+    //QCharRef operator[] ( uint position );
+    const QChar operator[](uint position) const;
+
+    static int compare(const MString & s1, const MString & s2, 
+                            Qt::CaseSensitivity cs) {return s1.compare(s2, cs);};
+    static int compare(const MString & s1, const MString & s2) 
+                        {return s1.compare(s2);};
+    static int compare(const MString & s1, const QLatin1String & s2, 
+                            Qt::CaseSensitivity cs = Qt::CaseSensitive) 
+                            {return s1.compare(s2, cs);};
+    static int compare(const QLatin1String & s1, const QString & s2, 
+                            Qt::CaseSensitivity cs = Qt::CaseSensitive) 
+                            {return -s2.compare(s1, cs);};
+
+    static MString fromAscii(const char * str, int size = -1) 
+                                {return MString(QString::fromAscii(str, size));};
+    static MString fromLatin1(const char * str, int size = -1) 
+                                {return MString(QString::fromLatin1(str, size));};
+    static MString fromLocal8Bit(const char * str, int size = -1) 
+                                {return MString(QString::fromLocal8Bit(str, size));};
+    static MString fromRawData(const QChar * unicode, int size) 
+                                {return MString(QString::fromRawData(unicode, size));};
+    static MString fromStdString(const std::string & str) 
+                                {return MString(QString::fromStdString(str));};
+    static MString fromStdWString(const std::wstring & str) 
+                                {return MString(QString::fromStdWString(str));};
+    static MString fromUcs4(const uint * unicode, int size = -1) 
+                                {return MString(QString::fromUcs4(unicode, size));};
+    static MString fromUtf8(const char * str, int size = -1) 
+                                {return MString(QString::fromUtf8(str, size));};
+    static MString fromUtf16(const ushort * unicode, int size = -1) 
+                                {return MString(QString::fromUtf16(unicode, size));};
+    static MString fromWCharArray(const wchar_t * string, int size = -1) 
+                                {return MString(QString::fromWCharArray(string, size));};
+    static int localeAwareCompare(const MString & s1, const MString & s2) 
+                                {return QString::localeAwareCompare(s1.toQString(), 
+                                s2.toQString());};
+
+    static MString number(long n, int base = 10) 
+                                {return MString(QString::number(n, base));};
+    static MString number(ulong n, int base = 10) 
+                                {return MString(QString::number(n, base));};
+    static MString number(int n, int base = 10) 
+                                {return MString(QString::number(n, base));};
+    static MString number(uint n, int base = 10) 
+                                {return MString(QString::number(n, base));};
+    static MString number(qlonglong n, int base = 10) 
+                                {return MString(QString::number(n, base));};
+    static MString number(qulonglong n, int base = 10) 
+                                {return MString(QString::number(n, base));};
+    static MString number(double n, char format = 'g', int precision = 6) 
+                                {return MString(QString::number(n, format, precision));};
+
+    friend QDataStream & operator<< (QDataStream & stream, const MString & string);
+    friend QDataStream & operator>> (QDataStream & stream, MString & string);
+
+};
+
+inline const MString operator+ (const MString & s1, const MString & s2) 
+                                    {return MString(s1.toQString() + s2.toQString());};
+inline const MString operator+ (const MString & s1, const char * s2) 
+                                    {return MString(s1.toQString() + s2);};
+inline const MString operator+ (const char * s1, const MString & s2) 
+                                    {return MString(s1 + s2.toQString());};
+inline const MString operator+ (const MString & s, char ch) 
+                                    {return MString(s.toQString() + ch);};
+inline const MString operator+ (char ch, const MString & s) 
+                                    {return MString(ch + s.toQString());};
+inline bool operator== (const char * s1, const MString & s2) 
+                                    {return (s1 == s2.toQString());};
+inline bool operator!= (const char * s1, const MString & s2) 
+                                    {return !(s1 != s2);};
+inline bool operator< (const char * s1, const MString & s2) 
+                                    {return (s1 < s2.toQString());};
+inline bool operator<= (const char * s1, const MString & s2) 
+                                    {return (s1 <= s2.toQString());};
+inline bool operator> (const char * s1, const MString & s2) 
+                                    {return !(s1 <= s2);};
+inline bool operator>= (const char * s1, const MString & s2) 
+                                    {return !(s1 < s2);};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(MString::SectionFlags)
+#endif
+
+/* vim: set expandtab tabstop=4 shiftwidth=4: */
Index: mythtv/libs/libmyth/mstring.cpp
===================================================================
--- mythtv/libs/libmyth/mstring.cpp	(revision 0)
+++ mythtv/libs/libmyth/mstring.cpp	(revision 0)
@@ -0,0 +1,1223 @@
+/*
+ *  Class MString: a thread-safe version of QString
+ *
+ *  Copyright (C) 2008 Jerome Brock <jpbrock@users.sourceforge.net>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+// Avoid deadlock: do not read/write from another MString from within 
+// this class while holding your own lock!
+//
+// Don't bypass the thread safety of this class, i.e. don't bypass the lock by 
+// reading another MString's private QString directly // Use the 'toString()' 
+// method to retrieve the string in a thread-safe manner
+//
+// According to the documentation 
+// (see 4.3/threads.html#threads-and-implicit-sharing) sharing QStrings 
+// between threads is safe in QT4 as related to QString's implicit sharing.  
+// In MString we are covering the thread safety for the QString objects, 
+// themselves.
+
+#include "mstring.h"
+#include <QtCore/QStringList>
+#include <QtCore/QVector>
+
+
+MString & MString::append(const MString & str)
+{
+    const QString other_qstring = str.toQString();
+
+    QWriteLocker locker(&m_lock);
+
+    m_string.append(other_qstring);
+    return *this;
+};
+
+MString & MString::append(const QLatin1String & str)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.append(str);
+    return *this;
+};
+
+MString & MString::append(const QByteArray & ba)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.append(ba);
+    return *this;
+}
+
+MString & MString::append(const char * str)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.append(str);
+    return *this;
+}
+
+MString & MString::append(QChar ch)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.append(ch);
+    return *this;
+}
+
+MString MString::arg(const MString & a, int fieldWidth, const QChar & fillChar) const
+{
+    QString a_string = a.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.arg(a_string, fieldWidth, fillChar));
+}
+
+MString MString::arg(const MString & a1, const MString & a2) const
+{
+    QString a1_string = a1.toQString();
+    QString a2_string = a2.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.arg(a1_string, a2_string));
+}
+
+MString MString::arg(const MString & a1, const MString & a2, 
+			const MString & a3) const
+{
+    QString a1_string = a1.toQString();
+    QString a2_string = a2.toQString();
+    QString a3_string = a3.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.arg(a1_string, a2_string, a3_string));
+}
+
+MString MString::arg(const MString & a1, const MString & a2, 
+                        const MString & a3, const MString & a4) const
+{
+    QString a1_string = a1.toQString();
+    QString a2_string = a2.toQString();
+    QString a3_string = a3.toQString();
+    QString a4_string = a4.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.arg(a1_string, a2_string, a3_string, a4_string));
+}
+
+MString MString::arg(const MString & a1, const MString & a2, 
+                        const MString & a3, const MString & a4, 
+                        const MString & a5) const
+{
+    QString a1_string = a1.toQString();
+    QString a2_string = a2.toQString();
+    QString a3_string = a3.toQString();
+    QString a4_string = a4.toQString();
+    QString a5_string = a5.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.arg(a1_string, a2_string, a3_string, a4_string, 
+                    a5_string));
+}
+
+MString MString::arg(const MString & a1, const MString & a2, 
+                        const MString & a3, const MString & a4, 
+                        const MString & a5, const MString & a6) const
+{
+    QString a1_string = a1.toQString();
+    QString a2_string = a2.toQString();
+    QString a3_string = a3.toQString();
+    QString a4_string = a4.toQString();
+    QString a5_string = a5.toQString();
+    QString a6_string = a6.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.arg(a1_string, a2_string, a3_string, a4_string, 
+                    a5_string, a6_string));
+}
+
+MString MString::arg(const MString & a1, const MString & a2, 
+                        const MString & a3, const MString & a4, 
+                        const MString & a5, const MString & a6, 
+                        const MString & a7) const
+{
+    QString a1_string = a1.toQString();
+    QString a2_string = a2.toQString();
+    QString a3_string = a3.toQString();
+    QString a4_string = a4.toQString();
+    QString a5_string = a5.toQString();
+    QString a6_string = a6.toQString();
+    QString a7_string = a7.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.arg(a1_string, a2_string, a3_string, a4_string, 
+                    a5_string, a6_string, a7_string));
+}
+
+MString MString::arg(const MString & a1, const MString & a2, 
+                        const MString & a3, const MString & a4, 
+                        const MString & a5, const MString & a6, 
+                        const MString & a7, const MString & a8) const
+{
+    QString a1_string = a1.toQString();
+    QString a2_string = a2.toQString();
+    QString a3_string = a3.toQString();
+    QString a4_string = a4.toQString();
+    QString a5_string = a5.toQString();
+    QString a6_string = a6.toQString();
+    QString a7_string = a7.toQString();
+    QString a8_string = a8.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.arg(a1_string, a2_string, a3_string, a4_string, 
+                    a5_string, a6_string, a7_string, a8_string));
+}
+
+MString MString::arg(const MString & a1, const MString & a2, 
+                        const MString & a3, const MString & a4, 
+                        const MString & a5, const MString & a6, 
+                        const MString & a7, const MString & a8, 
+                        const MString & a9) const
+{
+    QString a1_string = a1.toQString();
+    QString a2_string = a2.toQString();
+    QString a3_string = a3.toQString();
+    QString a4_string = a4.toQString();
+    QString a5_string = a5.toQString();
+    QString a6_string = a6.toQString();
+    QString a7_string = a7.toQString();
+    QString a8_string = a8.toQString();
+    QString a9_string = a9.toQString();
+
+    QReadLocker locker(&m_lock);
+    
+    return MString(m_string.arg(a1_string, a2_string, a3_string, a4_string, 
+                    a5_string, a6_string, a7_string, a8_string, a9_string));
+}
+
+const QChar MString::at(int position) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.at(position);
+}
+
+int MString::capacity() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.capacity();
+}
+
+void MString::chop(int n)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.chop(n);
+}
+
+void MString::clear()
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.clear();
+}
+
+int MString::compare(const MString & other) const
+{
+    const QString other_qstring = other.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.compare(other_qstring);
+}
+
+int MString::compare(const MString & other, Qt::CaseSensitivity cs) const
+{
+    const QString other_qstring = other.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.compare(other_qstring, cs);
+}
+
+int MString::compare(const QLatin1String & other, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.compare(other, cs);
+}
+
+const QChar * MString::constData() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.constData();
+}
+
+bool MString::contains(const MString & str, Qt::CaseSensitivity cs) const
+{
+    const QString other_qstring = str.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.contains(other_qstring, cs);
+}
+
+bool MString::contains(QChar ch, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.contains(ch, cs);
+}
+
+bool MString::contains(const QRegExp & rx) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.contains(rx);
+}
+
+int MString::count(const MString & str, Qt::CaseSensitivity cs) const
+{
+    const QString other_qstring = str.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.count(other_qstring, cs);
+}
+
+int MString::count(QChar ch, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.count(ch, cs);
+}
+
+int MString::count(const QRegExp & rx) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.count(rx);
+}
+
+int MString::count() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.count();
+}
+
+bool MString::endsWith(const MString & s, Qt::CaseSensitivity cs) const
+{
+    const QString other_qstring = s.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.endsWith(other_qstring, cs);
+}
+
+bool MString::endsWith(const QLatin1String & s, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.endsWith(s, cs);
+}
+
+bool MString::endsWith(const QChar & c, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.endsWith(c, cs);
+}
+
+MString & MString::fill(QChar ch, int size)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.fill(ch, size);
+    return *this;
+}
+
+int MString::indexOf(const MString & str, int from, Qt::CaseSensitivity cs) const
+{
+    const QString other_qstring = str.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.indexOf(other_qstring, from, cs);
+}
+
+int MString::indexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.indexOf(ch, from, cs);
+}
+
+int MString::indexOf(const QRegExp & rx, int from) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.indexOf(rx, from);
+}
+
+MString & MString::insert(int position, const MString & str)
+{
+    const QString other_qstring = str.toQString();
+
+    QWriteLocker locker(&m_lock);
+
+    m_string.insert(position, other_qstring);
+    return *this;
+}
+
+MString & MString::insert(int position, const QLatin1String & str)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.insert(position, str);
+    return *this;
+}
+
+MString & MString::insert(int position, const QChar * unicode, int size)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.insert(position, unicode, size);
+    return *this;
+}
+
+MString & MString::insert(int position, QChar ch)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.insert(position, ch);
+    return *this;
+}
+
+bool MString::isEmpty() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.isEmpty();
+}
+
+bool MString::isNull() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.isNull();
+}
+
+int MString::lastIndexOf(const MString & str, int from, Qt::CaseSensitivity cs) const
+{
+    const QString other_qstring = str.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.lastIndexOf(other_qstring, from, cs);
+}
+
+int MString::lastIndexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.lastIndexOf(ch, from, cs);
+}
+
+int MString::lastIndexOf(const QRegExp & rx, int from) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.lastIndexOf(rx, from);
+}
+
+MString MString::left(int n) const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.left(n));
+}
+
+MString MString::leftJustified(int width, QChar fill, bool truncate) const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.leftJustified(width, fill, truncate));
+}
+
+int MString::length() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.length();
+}
+
+int MString::localeAwareCompare(const MString & other) const
+{
+    const QString other_qstring = other.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.localeAwareCompare(other_qstring);
+}
+
+MString MString::mid(int position, int n) const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.mid(position, n));
+}
+
+MString MString::normalized(QString::NormalizationForm mode) const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.normalized(mode));
+}
+
+MString MString::normalized(QString::NormalizationForm mode, 
+                                QChar::UnicodeVersion version) const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.normalized(mode, version));
+}
+
+MString & MString::prepend(const MString & str)
+{
+    const QString other_qstring = str.toQString();
+
+    QWriteLocker locker(&m_lock);
+
+    m_string.prepend(other_qstring);
+    return *this;
+}
+
+MString & MString::prepend(const QLatin1String & str)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.prepend(str);
+    return *this;
+}
+
+MString & MString::prepend(const QByteArray & ba)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.prepend(ba);
+    return *this;
+}
+
+MString & MString::prepend(const char * str)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.prepend(str);
+    return *this;
+}
+
+MString & MString::prepend(QChar ch)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.prepend(ch);
+    return *this;
+}
+
+MString & MString::remove(int position, int n)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.remove(position, n);
+    return *this;
+}
+
+MString & MString::remove(const MString & str, Qt::CaseSensitivity cs)
+{
+    const QString other_qstring = str.toQString();
+
+    QWriteLocker locker(&m_lock);
+    m_string.remove(other_qstring, cs);
+    return *this;
+}
+
+MString & MString::remove(QChar ch, Qt::CaseSensitivity cs)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.remove(ch, cs);
+    return *this;
+}
+
+MString & MString::remove(const QRegExp & rx)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.remove(rx);
+    return *this;
+}
+
+MString & MString::replace(int position, int n, const MString & after)
+{
+    const QString other_qstring = after.toQString();
+
+    QWriteLocker locker(&m_lock);
+    m_string.replace(position, n, other_qstring);
+    return *this;
+}
+
+MString & MString::replace(int position, int n, const QChar * unicode, int size)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.replace(position, n, unicode, size);
+    return *this;
+}
+
+MString & MString::replace(int position, int n, QChar after)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.replace(position, n, after);
+    return *this;
+}
+
+MString & MString::replace(const MString & before, const MString & after, 
+                            Qt::CaseSensitivity cs)
+{
+    const QString before_qstring = before.toQString();
+    const QString after_qstring = after.toQString();
+
+    QWriteLocker locker(&m_lock);
+
+    m_string.replace(before_qstring, after_qstring, cs);
+    return *this;
+}
+
+MString & MString::replace(QChar ch, const MString & after, Qt::CaseSensitivity cs)
+{
+    const QString after_qstring = after.toQString();
+
+    QWriteLocker locker(&m_lock);
+
+    m_string.replace(ch, after_qstring, cs);
+    return *this;
+}
+
+MString & MString::replace(QChar before, QChar after, Qt::CaseSensitivity cs)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.replace(before, after, cs);
+    return *this;
+}
+
+MString & MString::replace(const QRegExp & rx, const MString & after)
+{
+    const QString after_qstring = after.toQString();
+
+    QWriteLocker locker(&m_lock);
+
+    m_string.replace(rx, after_qstring);
+    return *this;
+}
+
+void MString::reserve(int size)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.reserve(size);
+}
+
+void MString::resize(int size)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.resize(size);
+}
+
+MString MString::right(int n) const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.right(n));
+}
+
+MString MString::rightJustified(int width, QChar fill, bool truncate) const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.rightJustified(width, fill, truncate));
+}
+
+MString MString::section(QChar sep, int start, int end, SectionFlags flags) const
+{
+    int qflag_int = flags;
+    QString::SectionFlags qflags(qflag_int);
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.section(sep, start, end, qflags));
+}
+
+MString MString::section(const MString & sep, int start, int end, 
+                            SectionFlags flags) const
+{
+    const QString sep_qstring = sep.toQString();
+    int qflag_int = flags;
+    QString::SectionFlags qflags(qflag_int);
+
+    QReadLocker locker(&m_lock);
+    return MString(m_string.section(sep_qstring, start, end, qflags));
+}
+
+MString MString::section(const QRegExp & reg, int start, int end, 
+                            SectionFlags flags) const
+{
+    int qflag_int = flags;
+    QString::SectionFlags qflags(qflag_int);
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.section(reg, start, end, qflags));
+}
+
+MString & MString::setNum(uint n, int base)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, base);
+    return *this;
+}
+
+MString & MString::setNum(long n, int base)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, base);
+    return *this;
+}
+
+MString & MString::setNum(ulong n, int base)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, base);
+    return *this;
+}
+
+MString & MString::setNum(qlonglong n, int base)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, base);
+    return *this;
+}
+
+MString & MString::setNum(qulonglong n, int base)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, base);
+    return *this;
+}
+
+MString & MString::setNum(short n, int base)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, base);
+    return *this;
+}
+
+MString & MString::setNum(ushort n, int base)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, base);
+    return *this;
+}
+
+MString & MString::setNum(double n, char format, int precision)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, format, precision);
+    return *this;
+}
+
+MString & MString::setNum(float n, char format, int precision)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setNum(n, format, precision);
+    return *this;
+}
+
+MString & MString::setUnicode(const QChar * unicode, int size)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setUnicode(unicode, size);
+    return *this;
+}
+
+MString & MString::setUtf16(const ushort * unicode, int size)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.setUtf16(unicode, size);
+    return *this;
+}
+
+MString MString::simplified() const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.simplified());
+}
+
+int MString::size() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.size();
+}
+
+QStringList MString::split(const MString & sep, SplitBehavior behavior, 
+                            Qt::CaseSensitivity cs) const
+{
+    const QString sep_qstring = sep.toQString();
+
+    QReadLocker locker(&m_lock);
+    return m_string.split(sep_qstring, (QString::SplitBehavior)behavior, cs);
+}
+
+QStringList MString::split(const QChar & sep, SplitBehavior behavior, 
+                            Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.split(sep, (QString::SplitBehavior)behavior, cs);
+}
+
+QStringList MString::split(const QRegExp & rx, SplitBehavior behavior) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.split(rx, (QString::SplitBehavior)behavior);
+}
+
+void MString::squeeze()
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.squeeze();
+}
+
+bool MString::startsWith(const MString & s, Qt::CaseSensitivity cs) const
+{
+    const QString other_qstring = s.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return m_string.startsWith(other_qstring, cs);
+}
+
+bool MString::startsWith(const QLatin1String & s, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.startsWith(s, cs);
+}
+
+bool MString::startsWith(const QChar & c, Qt::CaseSensitivity cs) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.startsWith(c, cs);
+}
+
+QByteArray MString::toAscii() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toAscii();
+}
+
+MString MString::toCaseFolded() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toCaseFolded();
+}
+
+double MString::toDouble(bool * ok) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toDouble(ok);
+}
+
+float MString::toFloat(bool * ok) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toFloat(ok);
+}
+
+int MString::toInt(bool * ok, int base) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toInt(ok, base);
+}
+
+QByteArray MString::toLatin1() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toLatin1();
+}
+
+QByteArray MString::toLocal8Bit() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toLocal8Bit();
+}
+
+long MString::toLong(bool * ok, int base) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toLong(ok, base);
+}
+
+qlonglong MString::toLongLong(bool * ok, int base) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toLongLong(ok, base);
+}
+
+MString MString::toLower() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toLower();
+}
+
+QString MString::toQString() const
+{
+    QReadLocker locker(&m_lock);
+
+    return QString(m_string);
+}
+
+short MString::toShort(bool * ok, int base) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toShort(ok, base);
+}
+
+std::string MString::toStdString() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toStdString();
+}
+
+std::wstring MString::toStdWString() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toStdWString();
+}
+
+uint MString::toUInt(bool * ok, int base) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toUInt(ok, base);
+}
+
+ulong MString::toULong(bool * ok, int base) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toULong(ok, base);
+}
+
+qulonglong MString::toULongLong(bool * ok, int base) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toULongLong(ok, base);
+}
+
+ushort MString::toUShort(bool * ok, int base) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toUShort(ok, base);
+}
+
+QVector<uint> MString::toUcs4() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toUcs4();
+}
+
+MString MString::toUpper() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toUpper();
+}
+
+QByteArray MString::toUtf8() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toUtf8();
+}
+
+int MString::toWCharArray(wchar_t * array) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.toWCharArray(array);
+}
+
+MString MString::trimmed() const
+{
+    QReadLocker locker(&m_lock);
+
+    return MString(m_string.trimmed());
+}
+
+void MString::truncate(int position)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.truncate(position);
+}
+
+const QChar * MString::unicode() const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string.unicode();
+}
+
+MString & MString::vsprintf(const char * cformat, va_list ap)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string.vsprintf(cformat, ap);
+    return *this;
+}
+
+bool MString::operator< (const MString & other) const
+{
+    const QString other_qstring = other.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return (m_string < other_qstring);
+}
+
+bool MString::operator< (const QLatin1String & other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string < other);
+}
+
+bool MString::operator< (const QByteArray & other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string < other);
+}
+
+bool MString::operator< (const char * other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string < other);
+}
+
+bool MString::operator<= (const MString & other) const
+{
+    const QString other_qstring = other.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return (m_string <= other_qstring);
+}
+
+bool MString::operator<= (const QLatin1String & other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string <= other);
+}
+
+bool MString::operator<= (const QByteArray & other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string <= other);
+}
+
+bool MString::operator<= (const char * other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string <= other);
+}
+
+MString & MString::operator= (const MString & other)
+{
+    if (this == &other)
+    {
+        return *this; //skip self-assignment
+    }
+    const QString other_qstring = other.toQString();
+
+    QWriteLocker locker(&m_lock);
+
+    m_string = other_qstring;
+    return *this;
+}
+
+MString & MString::operator= (const QLatin1String & str)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string = str;
+    return *this;
+}
+
+MString & MString::operator= (const QByteArray & ba)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string = ba;
+    return *this;
+}
+
+MString & MString::operator= (const char * str)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string = str;
+    return *this;
+}
+
+MString & MString::operator= (char ch)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string = ch;
+    return *this;
+}
+
+MString & MString::operator= (QChar ch)
+{
+    QWriteLocker locker(&m_lock);
+
+    m_string = ch;
+    return *this;
+}
+
+bool MString::operator== (const MString & other) const
+{
+    const QString other_qstring = other.toQString();
+
+    QReadLocker locker(&m_lock);
+
+    return (m_string == other_qstring);
+}
+
+
+bool MString::operator== (const QLatin1String & other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string == other);
+}
+
+
+bool MString::operator== (const QByteArray & other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string == other);
+}
+
+bool MString::operator== (const char * other) const
+{
+    QReadLocker locker(&m_lock);
+
+    return (m_string == other);
+}
+
+const QChar MString::operator[](int position) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string[position];
+}
+
+const QChar MString::operator[](uint position) const
+{
+    QReadLocker locker(&m_lock);
+
+    return m_string[position];
+}
+
+QDataStream & operator<< (QDataStream & stream, const MString & string)
+{
+    QReadLocker locker(&(string.m_lock));
+
+    stream << string.m_string;
+    return stream;
+}
+
+QDataStream & operator>> (QDataStream & stream, MString & string)
+{
+    QWriteLocker locker(&(string.m_lock));
+
+    stream >> string.m_string;
+    return stream;
+}
+
+/* vim: set expandtab tabstop=4 shiftwidth=4: */
