Initial import from the monolithic kdelibs.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
techbase wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://community.kde.org/Frameworks/GitOldHistory

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, kdelibs frameworks branch, at commit
162066dbbecde401a7347a1cff4fe72a9c919f58

1 files changed, 181 insertions, 0 deletions

diff --git a/tier1/kconfig/src/core/bufferfragment_p.h b/tier1/kconfig/src/core/bufferfragment_p.h
new file mode 100644
index 00000000..5a753ad4
--- /dev/null
+++ b/tier1/kconfig/src/core/bufferfragment_p.h
@@ -0,0 +1,181 @@
+/*
+   This file is part of the KDE libraries
+   Copyright (c) 2008 Jakub Stachowski <qbast@go2.pl>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.
+*/
+
+#ifndef BUFFERFRAGMENT_H
+#define BUFFERFRAGMENT_H
+
+#define bf_isspace(str) ((str == ' ') || (str == '\t') || (str == '\r'))
+
+// This class provides wrapper around fragment of existing buffer (array of bytes). 
+// If underlying buffer gets deleted, all BufferFragment objects referencing it become invalid.
+// Use toByteArray() to make deep copy of the buffer fragment.
+// 
+// API is designed to subset of QByteArray methods with some changes:
+// - trim() is like QByteArray.trimmed(), but it modifies current object
+// - truncateLeft() provides way to cut off beginning of the buffer
+// - split() works more like strtok_r than QByteArray.split()
+// - truncateLeft() and mid() require position argument to be valid
+    
+class KConfigIniBackend::BufferFragment 
+{
+    
+public:
+
+    BufferFragment() : d(0), len(0) 
+    {
+    }
+    
+    BufferFragment(char* buf, int size) : d(buf), len(size) 
+    {
+    }
+
+    int length() const 
+    {
+        return len;
+    }
+
+    char at(unsigned int i) const 
+    {
+        Q_ASSERT(i < len);
+        return d[i];
+    }
+
+    void clear() 
+    {
+        len = 0;
+    }
+
+    const char* constData() const 
+    {
+        return d;
+    }
+
+    char* data() const 
+    {
+        return d;
+    }
+
+    void trim() 
+    {
+        while (bf_isspace(*d) && len > 0) {
+            d++;
+            len--;
+        }
+        while (len > 0 && bf_isspace(d[len - 1])) 
+            len--;
+    }
+
+    // similar to strtok_r . On first call variable pointed by start should be set to 0.
+    // Each call will update *start to new starting position. 
+    BufferFragment split(char c, unsigned int* start) 
+    {
+        while (*start < len) {
+            int end = indexOf(c, *start);
+            if (end == -1) end = len;
+            BufferFragment line(d + (*start), end - (*start));
+            *start = end + 1;
+            return line;
+        }
+        return BufferFragment();
+    }
+    
+    bool isEmpty() const 
+    {
+        return (len == 0);
+    }
+
+    BufferFragment left(unsigned int size) const 
+    {
+        return BufferFragment(d, qMin(size,len));
+    }
+
+    void truncateLeft(unsigned int size) 
+    {
+        Q_ASSERT(size <= len);
+        d += size;
+        len -= size;
+    }
+
+    void truncate(unsigned int pos) 
+    {
+        if (pos < len) len = pos;
+    }
+
+    bool isNull() const 
+    {
+        return (d == 0);
+    }
+        
+    BufferFragment mid(unsigned int pos, int length=-1) const 
+    {
+        Q_ASSERT(pos < len);
+        int size = length;
+        if (length == -1 || (pos + length) > len) 
+            size = len - pos;
+        return BufferFragment(d + pos, size);
+    }
+
+    bool operator==(const QByteArray& other) const
+    {
+        return (other.size() == (int)len && memcmp(d,other.constData(),len) == 0);
+    }
+
+    bool operator!=(const QByteArray& other) const 
+    {
+        return (other.size() != (int)len || memcmp(d,other.constData(),len) != 0);
+    }
+    
+    int indexOf(char c, unsigned int from = 0) const 
+    {
+        const char* cursor = d + from - 1;
+        const char* end = d + len;
+        while ( ++cursor < end) 
+            if (*cursor ==c ) 
+                return cursor - d; 
+        return -1;
+    }
+
+    int lastIndexOf(char c) const 
+    {
+        int from = len - 1;
+        while (from >= 0) 
+            if (d[from] == c) 
+                return from; 
+            else 
+                from--;
+        return -1;
+    }
+
+    QByteArray toByteArray() const {
+        return QByteArray(d,len);
+    }
+    
+    // this is faster than toByteArray, but returned QByteArray becomes invalid
+    // when buffer for this BufferFragment disappears
+    QByteArray toVolatileByteArray() const {
+        return QByteArray::fromRawData(d, len);
+    }
+
+private:
+    char* d;
+    unsigned int len;
+};
+
+#endif