Changeset 846 for trunk/src/corelib/tools/qbytearray.cpp

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/corelib/tools/qbytearray.cpp (modified) (18 diffs)

trunk/src/corelib/tools/qbytearray.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
@@ -47 +47 @@
 #include "qlocale.h"
 #include "qlocale_p.h"
-#include "qunicodetables_p.h"
 #include "qscopedpointer.h"
 #include <qdatastream.h>
@@ -154 +153 @@
     This function assumes that \a dst is at least \a len characters
     long.
+
+
+
+
 
     \sa qstrcpy()
@@ -847 +850 @@
     \l{implicitly shared}. This makes returning a QByteArray from a
     function very fast. If a shared instance is modified, it will be
-    copied (copy-on-write), and that takes \l{linear time}.
+    copied (copy-on-write),  \l{linear time}.
 
     \sa operator=()
@@ -1062 +1065 @@
 */
 
+
+
+
+
+
 /*! \fn char QByteArray::at(int i) const
 
@@ -1178 +1186 @@
     \snippet doc/src/snippets/code/src_corelib_tools_qbytearray.cpp 12
 
-    This operation is typically very fast (\l{constant time}),
-    because QByteArray preallocates extra space at the end of the
-    character data so it can grow without reallocating the entire
-    data each time.
+    Note: QByteArray is an \l{implicitly shared} class. Consequently,
+    if \e this is an empty QByteArray, then \e this will just share
+    the data held in \a ba. In this case, no copying of data is done,
+    taking \l{constant time}. If a shared instance is modified, it will
+    be copied (copy-on-write), taking \l{linear time}.
+
+    If \e this is not an empty QByteArray, a deep copy of the data is
+    performed, taking \l{linear time}.
+
+    This operation typically does not suffer from allocation overhead,
+    because QByteArray preallocates extra space at the end of the data
+    so that it may grow without reallocating for each append operation.
 
     \sa append(), prepend()
@@ -1466 +1482 @@
     Note: QByteArray is an \l{implicitly shared} class. Consequently,
     if \e this is an empty QByteArray, then \e this will just share
-    the data held in \a ba. In this case, no copying of data is done.
+    the data held in \a ba. In this case, no copying of data is done,
+    taking \l{constant time}. If a shared instance is modified, it will
+    be copied (copy-on-write), taking \l{linear time}.
+
+    If \e this is not an empty QByteArray, a deep copy of the data is
+    performed, taking \l{linear time}.
 
     \sa append(), insert()
@@ -1539 +1560 @@
     This is the same as insert(size(), \a ba).
 
-    This operation is typically very fast (\l{constant time}),
-    because QByteArray preallocates extra space at the end of the
-    character data so it can grow without reallocating the entire
-    data each time.
-
     Note: QByteArray is an \l{implicitly shared} class. Consequently,
     if \e this is an empty QByteArray, then \e this will just share
-    the data held in \a ba. In this case, no copying of data is done.
+    the data held in \a ba. In this case, no copying of data is done,
+    taking \l{constant time}. If a shared instance is modified, it will
+    be copied (copy-on-write), taking \l{linear time}.
+
+    If \e this is not an empty QByteArray, a deep copy of the data is
+    performed, taking \l{linear time}.
+
+    This operation typically does not suffer from allocation overhead,
+    because QByteArray preallocates extra space at the end of the data
+    so that it may grow without reallocating for each append operation.
 
     \sa operator+=(), prepend(), insert()
@@ -1788 +1813 @@
     } else {
         QByteArray copy(after);
-        // ### optimise me
+        // ### optimie me
         remove(pos, len);
         return insert(pos, copy);
@@ -1797 +1822 @@
 
     \overload
+
+
+
+
+
 */
 QByteArray &QByteArray::replace(int pos, int len, const char *after)
 {
-    int alen = qstrlen(after);
+    return replace(pos,len,after,qstrlen(after));
+}
+
+/*! \fn QByteArray &QByteArray::replace(int pos, int len, const char *after, int alen)
+
+    \overload
+
+    Replaces \a len bytes from index position \a pos with \a alen bytes
+    from the string \a after. \a after is allowed to have '\0' characters.
+
+    \since 4.7
+*/
+QByteArray &QByteArray::replace(int pos, int len, const char *after, int alen)
+{
     if (len == alen && (pos + len <= d->size)) {
         detach();
@@ -1811 +1854 @@
 }
 
-// ### optimise all other replace method, by offering
+// ### optimie all other replace method, by offering
 // QByteArray::replace(const char *before, int blen, const char *after, int alen)
 
@@ -2126 +2169 @@
         return QByteArray(); // not enough memory
 
-    qMemCopy(result.d->data, d->data, d->size);
+    py(result.d->data, d->data, d->size);
 
     int sizeSoFar = d->size;
@@ -2133 +2176 @@
     const int halfResultSize = resultSize >> 1;
     while (sizeSoFar <= halfResultSize) {
-        qMemCopy(end, result.d->data, sizeSoFar);
+        py(end, result.d->data, sizeSoFar);
         end += sizeSoFar;
         sizeSoFar <<= 1;
     }
-    qMemCopy(end, result.d->data, resultSize - sizeSoFar);
+    py(end, result.d->data, resultSize - sizeSoFar);
     result.d->data[resultSize] = '\0';
     result.d->size = resultSize;
@@ -2660 +2703 @@
     to the stream.
 
-    \sa {Format of the QDataStream operators}
+    \sa {s}
 */
 
@@ -2677 +2720 @@
     reference to the stream.
 
-    \sa {Format of the QDataStream operators}
+    \sa {s}
 */
 
@@ -3793 +3836 @@
     fail.
 
-    \sa data(), constData()
+    \sa data(), constData()
 */
 
@@ -3810 +3853 @@
     *x->array = '\0';
     return QByteArray(x, 0, 0);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 }
 
@@ -4207 +4281 @@
 
 /*!
-    \fn QByteArray& QByteArray::setRawData(const char *a, uint n)
-
-    Use fromRawData() instead.
-*/
-
-/*!
     \fn void QByteArray::resetRawData(const char *data, uint n)