9 files changed, 552 insertions, 15 deletions

diff --git a/src/unstable/blobbuilder.cpp b/src/unstable/blobbuilder.cpp
index 43c0779..fd62cb0 100644
--- a/src/unstable/blobbuilder.cpp
+++ b/src/unstable/blobbuilder.cpp
@@ -93,7 +93,7 @@ Bu::BlobBuilderCore::BlobBuilderCore( const Bu::BlobBuilderCore &rSrc ) :
     pLast( 0 ),
     iLength( rSrc.iLength )
 {
-
+    throw Bu::ExceptionBase("Not yet implemented.");
 }
 
 Bu::BlobBuilderCore::~BlobBuilderCore()
diff --git a/src/unstable/text.cpp b/src/unstable/text.cpp
index 9e5670d..be4c10f 100644
--- a/src/unstable/text.cpp
+++ b/src/unstable/text.cpp
@@ -6,22 +6,35 @@
  */
 
 #include "bu/text.h"
+#include "bu/textbuilder.h"
+
+#include "bu/exceptionbase.h"
+
 #include <string.h>
 
 Bu::Text::Text() :
     pData( NULL ),
-    iSize( 0 ),
-    iCodePoints( 0 )
+    bIsBmpOnly( true ),
+    iSize( 0 )
 {
 }
 
 Bu::Text::Text( const Text &rSrc ) :
     pData( NULL ),
-    iSize( rSrc.iSize ),
-    iCodePoints( rSrc.iCodePoints )
+    bIsBmpOnly( rSrc.bIsBmpOnly ),
+    iSize( rSrc.iSize )
+{
+    pData = new CodePoint[iSize];
+    memcpy( pData, rSrc.pData, sizeof(CodePoint)*iSize );
+}
+
+Bu::Text::Text( const TextBuilder &rSrc ) :
+    pData( NULL ),
+    bIsBmpOnly( true ),
+    iSize( rSrc.getSize() )
 {
-    pData = new uint16_t[iSize];
-    memcpy( pData, rSrc.pData, sizeof(uint16_t)*iSize );
+    pData = new CodePoint[iSize];
+    
 }
 
 Bu::Text::~Text()
@@ -30,4 +43,35 @@ Bu::Text::~Text()
     pData = NULL;
 }
 
+bool Bu::Text::isEmpty() const
+{
+    return (iSize == 0);
+}
+
+bool Bu::Text::isBmpOnly() const
+{
+    return bIsBmpOnly;
+}
+
+int32_t Bu::Text::getSize() const
+{
+    return iSize;
+}
+
+int32_t Bu::Text::getSizeInBytes() const
+{
+    return iSize*sizeof(CodePoint);
+}
+
+Bu::CodePoint Bu::Text::operator[]( int32_t iIndex ) const
+{
+    if( iIndex < 0 || iIndex >= iSize )
+        throw Bu::ExceptionBase("Index out of range.");
+    return pData[iIndex];
+}
+
+Bu::CodePoint *Bu::Text::getData() const
+{
+    return pData;
+}
 
diff --git a/src/unstable/text.h b/src/unstable/text.h
index 1d623ff..c57dcfb 100644
--- a/src/unstable/text.h
+++ b/src/unstable/text.h
@@ -12,6 +12,8 @@
 
 namespace Bu
 {
+    class TextBuilder;
+
     /**
      * Represents a string of text. Human readable language. This should be
      * used any time you're dealing with actual text and not just binary
@@ -27,11 +29,6 @@ namespace Bu
      * multilpe code points. In addition, a code point can also represent
      * formatting or display inforamtion.
      *
-     * Internally all data is stored in UTF-16, which is a fair compromise for
-     * mose text.  All characters from all modern natural languages fit within
-     * the Basic Multilingual Plane, which requires only a single 16 bit value
-     * to represent it.  However, when iterating through or addressing data
-     * in the Text object all work is done on a code point basis.
      */
     class Text
     {
@@ -43,20 +40,22 @@ namespace Bu
     public:
         Text();
         Text( const Text &rSrc );
+        Text( const TextBuilder &rSrc );
         virtual ~Text();
 
         bool isEmpty() const;
         bool isBmpOnly() const;
         int32_t getSize() const;
         int32_t getSizeInBytes() const;
+        CodePoint operator[]( int32_t iIndex ) const;
 
-        uint16_t *getRawData() const;
+        CodePoint *getData() const;
 //        Text transform( (CodePoint *)(*pCallback)( CodePoint * ) );
 
     private:
-        uint16_t *pData;
+        CodePoint *pData;
+        bool bIsBmpOnly;
         int32_t iSize;
-        int32_t iCodePoints;
     };
     typedef Text::CodePoint CodePoint;
 }
diff --git a/src/unstable/textbuilder.cpp b/src/unstable/textbuilder.cpp
index 73271f8..acd3501 100644
--- a/src/unstable/textbuilder.cpp
+++ b/src/unstable/textbuilder.cpp
@@ -5,4 +5,310 @@
  * terms of the license contained in the file LICENSE.
  */
 
+#include "bu/textbuilder.h"
+
+#include "bu/exceptionbase.h"
+#include "bu/text.h"
+
+#define PAGE_SIZE       16
+
+Bu::TextBuilderCore::Chunk::Chunk( const CodePoint *pSrc, int32_t iLength ) :
+    iLength( iLength ),
+    pData( 0 ),
+    pNext( 0 )
+{
+    if( iLength < PAGE_SIZE )
+    {
+        pData = new CodePoint[PAGE_SIZE];
+    }
+    else
+    {
+        pData = new CodePoint[iLength];
+    }
+    memcpy( pData, pSrc, iLength*sizeof(CodePoint) );
+}
+
+Bu::TextBuilderCore::Chunk::~Chunk()
+{
+    delete[] pData;
+    pData = 0;
+    pNext = 0;
+}
+
+void Bu::TextBuilderCore::Chunk::append( const Bu::CodePoint *&pSrc,
+        int32_t &iLength )
+{
+    if( this->iLength >= PAGE_SIZE )
+    {
+        // This chink is full, just return.
+        return;
+    }
+    int32_t iCopy = PAGE_SIZE-this->iLength;
+    if( iCopy > iLength )
+    {
+        iCopy = iLength;
+    }
+    memcpy( pData+this->iLength, pSrc, iCopy*sizeof(Bu::CodePoint) );
+    this->iLength += iCopy;
+    pSrc += iCopy;
+    iLength -= iCopy;
+}
+
+Bu::TextBuilderCore::Chunk *Bu::TextBuilderCore::Chunk::split( int32_t iIndex )
+{
+    if( iIndex == 0 )
+        return NULL;
+
+    if( iIndex >= iLength )
+        return NULL;
+
+    Chunk *pNew = new Chunk( pData+iIndex, iLength-iIndex );
+    iLength -= iIndex;
+    pNew->pNext = pNext;
+    pNext = pNew;
+
+    return pNew;
+}
+
+
+//////
+// TextBuilderCore
+//
+Bu::TextBuilderCore::TextBuilderCore() :
+    pFirst( 0 ),
+    pLast( 0 ),
+    iLength( 0 )
+{
+}
+
+Bu::TextBuilderCore::TextBuilderCore( const TextBuilderCore &rSrc ) :
+    pFirst( 0 ),
+    pLast( 0 ),
+    iLength( rSrc.iLength )
+{
+    throw Bu::ExceptionBase("Not yet implemented.");
+}
+
+Bu::TextBuilderCore::~TextBuilderCore()
+{
+    clear();
+}
+
+void Bu::TextBuilderCore::clear()
+{
+    Chunk *pCur = pFirst;
+    while( pCur )
+    {
+        Chunk *pNext = pCur->pNext;
+        delete pCur;
+        pCur = pNext;
+    }
+    pFirst = pLast = 0;
+    iLength = 0;
+}
+
+void Bu::TextBuilderCore::append( const CodePoint *pSrc, int32_t iLength )
+{
+    this->iLength += iLength;
+    if( pFirst == 0 )
+    {
+        // Nothing in the list, just add a chunk.
+        pFirst = pLast = new Chunk( pSrc, iLength );
+        return;
+    }
+    else if( pLast->iLength < PAGE_SIZE )
+    {
+        // Append to the last chunk first, this will modify pSrc & iLength.
+        pLast->append( pSrc, iLength );
+    }
+
+    // If there's unused data at the end, append it now.
+    if( iLength > 0 )
+    {
+        pLast->pNext = new Chunk( pSrc, iLength );
+        pLast = pLast->pNext;
+    }
+}
+
+void Bu::TextBuilderCore::prepend( const CodePoint *pSrc, int32_t iLength )
+{
+    if( pFirst == 0 )
+    {
+        pFirst = pLast = new Chunk( pSrc, iLength );
+    }
+    else
+    {
+        Chunk *pNew = new Chunk( pSrc, iLength );
+        pNew->pNext = pFirst;
+        pFirst = pNew;
+    }
+    this->iLength += iLength;
+}
+
+void Bu::TextBuilderCore::insert( int32_t iBefore, const CodePoint *pSrc, int32_t iLength )
+{
+    if( iBefore <= 0 )
+    {
+        prepend( pSrc, iLength );
+        return;
+    }
+    if( iBefore >= this->iLength )
+    {
+        append( pSrc, iLength );
+        return;
+    }
+
+    Chunk *pCur = pFirst;
+    while( pCur )
+    {
+        if( iBefore == 0 )
+        {
+            // Insert between chunks, no splitting required.
+            Chunk *pNew = new Chunk( pSrc, iLength );
+            pNew->pNext = pCur->pNext;
+            pCur->pNext = pNew;
+            if( pLast == pCur )
+                pLast = pNew;
+        }
+        if( iBefore < pCur->iLength )
+        {
+            // This is the chunk we need to split.
+            Chunk *pNew = pCur->split( iBefore );
+            if( pLast == pCur )
+                pLast = pNew;
+            continue;
+        }
+        pCur = pCur->pNext;
+    }
+    this->iLength = iLength;
+}
+
+void Bu::TextBuilderCore::set( const CodePoint *pSrc, int32_t iLength )
+{
+    clear();
+    append( pSrc, iLength );
+}
+
+void Bu::TextBuilderCore::copyTo( void *pDestRaw, int32_t iLength )
+{
+    CodePoint *pDest = reinterpret_cast<CodePoint *>( pDestRaw );
+
+    Chunk *pCur = pFirst;
+    while( pCur && iLength )
+    {
+        int32_t iChunkLen = pCur->iLength;
+        if( iChunkLen > iLength )
+            iChunkLen = iLength;
+
+        memcpy( pDest, pCur->pData, iChunkLen*sizeof(CodePoint) );
+        pDest += iChunkLen;
+        iLength -= iChunkLen;
+
+        pCur = pCur->pNext;
+    }
+}
+
+Bu::CodePoint Bu::TextBuilderCore::getAt( int32_t iIndex ) const
+{
+    if( iIndex < 0 || iIndex >= iLength )
+        throw Bu::ExceptionBase("Requested index is out of range.");
+
+    Chunk *pCur = pFirst;
+    while( iIndex >= pCur->iLength )
+    {
+        iIndex -= pCur->iLength;
+        pCur = pCur->pNext;
+    }
+    return pCur->pData[iIndex];
+}
+
+/////
+// TextBuilder
+//
+
+Bu::TextBuilder::TextBuilder()
+{
+}
+
+Bu::TextBuilder::TextBuilder( const Text &rSrc )
+{
+    core->append( rSrc.getData(), rSrc.getSize() );
+}
+
+Bu::TextBuilder::TextBuilder( const TextBuilder &rSrc ) :
+    Bu::SharedCore<Bu::TextBuilder, Bu::TextBuilderCore>( rSrc )
+{
+}
+
+Bu::TextBuilder::~TextBuilder()
+{
+}
+
+void Bu::TextBuilder::set( const Text &rSrc )
+{
+    _hardCopy();
+    core->set( rSrc.getData(), rSrc.getSize() );
+}
+
+void Bu::TextBuilder::append( const Text &rSrc )
+{
+    _hardCopy();
+    core->append( rSrc.getData(), rSrc.getSize() );
+}
+
+void Bu::TextBuilder::append( const CodePoint *pSrc, int32_t iLength )
+{
+    _hardCopy();
+    core->append( pSrc, iLength );
+}
+
+void Bu::TextBuilder::prepend( const Text &rSrc )
+{
+    _hardCopy();
+    core->prepend( rSrc.getData(), rSrc.getSize() );
+}
+
+void Bu::TextBuilder::insert( int32_t iBefore, const Text &rSrc )
+{
+    _hardCopy();
+    core->insert( iBefore, rSrc.getData(), rSrc.getSize() );
+}
+
+void Bu::TextBuilder::clear()
+{
+    _hardCopy();
+    core->clear();
+}
+
+int32_t Bu::TextBuilder::getSize() const
+{
+    return core->iLength;
+}
+
+Bu::Text Bu::TextBuilder::getText() const
+{
+    return Text( *this );
+}
+
+void Bu::TextBuilder::copyTo( void *pDestRaw, int32_t iDestSize ) const
+{
+    core->copyTo( pDestRaw, iDestSize );
+}
+
+Bu::CodePoint Bu::TextBuilder::operator[]( int32_t iIndex ) const
+{
+    return core->getAt( iIndex );
+}
+
+Bu::TextBuilder &Bu::TextBuilder::operator=( const Text &rSrc )
+{
+    set( rSrc );
+    return *this;
+}
+
+Bu::TextBuilder &Bu::TextBuilder::operator==( const Text &rSrc )
+{
+
+    return *this;
+}
 
diff --git a/src/unstable/textbuilder.h b/src/unstable/textbuilder.h
index 73271f8..8c49f2a 100644
--- a/src/unstable/textbuilder.h
+++ b/src/unstable/textbuilder.h
@@ -5,4 +5,83 @@
  * terms of the license contained in the file LICENSE.
  */
 
+#ifndef BU_TEXT_BUILDER_H
+#define BU_TEXT_BUILDER_H
+
+#include <stdint.h>
+#include "bu/sharedcore.h"
+#include "bu/text.h"
+
+namespace Bu
+{
+    class TextBuilder;
+    
+    /** @cond DEVEL */
+    class TextBuilderCore
+    {
+    friend class TextBuilder;
+    friend class SharedCore<TextBuilder, TextBuilderCore>;
+    private:
+        class Chunk
+        {
+        public:
+            Chunk( const CodePoint *pSrc, int32_t iLength );
+            ~Chunk();
+
+            void append( const CodePoint *&pSrc, int32_t &iLength );
+
+            Chunk *split( int32_t iIndex );
+
+            int32_t iLength;
+            CodePoint *pData;
+            Chunk *pNext;
+        };
+
+        TextBuilderCore();
+        TextBuilderCore( const TextBuilderCore &rSrc );
+        virtual ~TextBuilderCore();
+
+        void clear();
+        void append( const CodePoint *pSrc, int32_t iLength );
+        void prepend( const CodePoint *pSrc, int32_t iLength );
+        void insert( int32_t iBefore, const CodePoint *pSrc, int32_t iLength );
+        void set( const CodePoint *pSrc, int32_t iLength );
+        void copyTo( void *pDestRaw, int32_t iLength );
+        CodePoint getAt( int32_t iIndex ) const;
+
+        Chunk *pFirst;
+        Chunk *pLast;
+        int32_t iLength;
+    };
+
+    class TextBuilder : public Bu::SharedCore<TextBuilder, TextBuilderCore>
+    {
+    protected:
+        using SharedCore<TextBuilder, TextBuilderCore>::core;
+        using SharedCore<TextBuilder, TextBuilderCore>::_hardCopy;
+
+    public:
+        TextBuilder();
+        TextBuilder( const Text &rSrc );
+        TextBuilder( const TextBuilder &rSrc );
+        virtual ~TextBuilder();
+
+        void set( const Text &rSrc );
+        void append( const Text &rSrc );
+        void append( const CodePoint *pSrc, int32_t iLength );
+        void prepend( const Text &rSrc );
+        void insert( int32_t iBefore, const Text &rSrc );
+        void clear();
+
+        int32_t getSize() const;
+        Text getText() const;
+        void copyTo( void *pDestRaw, int32_t iDestSize ) const;
+        CodePoint operator[]( int32_t iIndex ) const;
+
+        TextBuilder &operator=( const Text &rSrc );
+        TextBuilder &operator==( const Text &rSrc );
+    };
+}
+
+#endif
 
diff --git a/src/unstable/textcodec.cpp b/src/unstable/textcodec.cpp
index e69de29..0ac791e 100644
--- a/src/unstable/textcodec.cpp
+++ b/src/unstable/textcodec.cpp
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/textcodec.h"
+
+Bu::TextCodec::TextCodec()
+{
+}
+
+Bu::TextCodec::~TextCodec()
+{
+}
+
diff --git a/src/unstable/textcodec.h b/src/unstable/textcodec.h
index e69de29..6ae392e 100644
--- a/src/unstable/textcodec.h
+++ b/src/unstable/textcodec.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef TEXT_CODEC_H
+#define TEXT_CODEC_H
+
+#include "bu/text.h"
+#include "bu/blob.h"
+
+namespace Bu
+{
+    class Text;
+    class Blob;
+    class TextBuilder;
+    class BlobBuilder;
+
+    /**
+     * Represents a textual format and the routines to convert from that
+     * format to unicode code points and vica versa.
+     */
+    class TextCodec
+    {
+    public:
+        TextCodec();
+        virtual ~TextCodec();
+
+//        virtual Blob encode( const Text &rSource );
+//        virtual Text decode( const Blob &rSource, int32_t &rBytesUsed );
+
+        virtual void encode( BlobBuilder &rTarget, const Text &rSource )=0;
+        virtual int32_t decode( TextBuilder &rTarget, const Blob &rSource )=0;
+
+    private:
+    };
+};
+
+#endif
diff --git a/src/unstable/textcodecutf8.cpp b/src/unstable/textcodecutf8.cpp
index e69de29..ce4e0a2 100644
--- a/src/unstable/textcodecutf8.cpp
+++ b/src/unstable/textcodecutf8.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#include "bu/textcodecutf8.h"
+
+Bu::TextCodecUtf8::TextCodecUtf8()
+{
+}
+
+Bu::TextCodecUtf8::~TextCodecUtf8()
+{
+}
+
+void Bu::TextCodecUtf8::encode( BlobBuilder &rTarget, const Text &rSource )
+{
+}
+
+int32_t Bu::TextCodecUtf8::decode( TextBuilder &rTarget, const Blob &rSource )
+{
+}
+
diff --git a/src/unstable/textcodecutf8.h b/src/unstable/textcodecutf8.h
index e69de29..f565f57 100644
--- a/src/unstable/textcodecutf8.h
+++ b/src/unstable/textcodecutf8.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2007-2019 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
+#ifndef TEXT_CODEC_UTF8_H
+#define TEXT_CODEC_UTF8_H
+
+#include "bu/textcodec.h"
+
+namespace Bu
+{
+    class TextCodecUtf8 : public TextCodec
+    {
+    public:
+        TextCodecUtf8();
+        virtual ~TextCodecUtf8();
+
+        virtual void encode( BlobBuilder &rTarget, const Text &rSource );
+        virtual int32_t decode( TextBuilder &rTarget, const Blob &rSource );
+    };
+}
+
+#endif