UtfString is going really well. It can now parse Utf8, Utf16 (le,be), and

Utf32 (le,be).  The internal storage seems to be working fine, although we do
have a problem with random access, but at least we can tell which half of a
surrogate pair we're on, so we can always rapidly determine the entire code
point from any utf16 index that we're on.
The only optomization that I'm not doing yet is reading in entire 16bit or 32bit
words at a time and converting them from their byte order to native.  There are
a few potential issues with that, so we'll see.

I added a couple of testing datafiles and a test program, I'll delete them all
just as soon as it's verified to write correctly.

1 files changed, 49 insertions, 3 deletions

diff --git a/src/utfstring.h b/src/utfstring.h
index 79ef62e..8448ea4 100644
--- a/src/utfstring.h
+++ b/src/utfstring.h
@@ -14,6 +14,7 @@
 namespace Bu
 {
         class String;
+        class Stream;
 
         /**
          * UtfChar isn't actually a character, unicode specifies "code points" not
@@ -35,7 +36,10 @@ namespace Bu
                         Utf16be,
                         Utf16le,
                         Utf32,
-                        Ucs16,
+                        Utf32be,
+                        Utf32le,
+                        Ucs2,
+                        Ucs4,
                         GuessEncoding
                 };
 
@@ -43,17 +47,59 @@ namespace Bu
                 UtfString( const Bu::String &sInput, Encoding eEnc=Utf8 );
                 virtual ~UtfString();
 
+                class iterator
+                {
+                private:
+                        iterator( UtfString *pSrc, int iCodePos ) :
+                                pSrc( pSrc ), iCodePos( iCodePos )
+                        {
+                        }
+
+                public:
+                        iterator() :
+                                pSrc( NULL ), iCodePos( 0 )
+                        {
+                        }
+
+                        UtfChar operator*()
+                        {
+                                if( !pSrc )
+                                        throw Bu::ExceptionBase("invalid UtfString::iterator dereferenced.");
+                                return pSrc->nextChar( iCodePos );
+                        }
+
+                private:
+                        UtfString *pSrc;
+                        int iCodePos;
+                };
+
                 void append( UtfChar ch );
 
                 void set( const Bu::String &sInput, Encoding eEnc=Utf8 );
                 void setUtf8( const Bu::String &sInput );
                 void setUtf16( const Bu::String &sInput );
-//              void setUtf16be( const Bu::String &sInput );
-//              void setUtf16le( const Bu::String &sInput );
+                void setUtf16be( const Bu::String &sInput );
+                void setUtf16le( const Bu::String &sInput );
+                void setUtf32( const Bu::String &sInput );
+                void setUtf32be( const Bu::String &sInput );
+                void setUtf32le( const Bu::String &sInput );
+
+                void write( Bu::Stream &sOut, Encoding eEnc=Utf8 );
+                void writeUtf8( Bu::Stream &sOut );
+                void writeUtf16( Bu::Stream &sOut );
+                void writeUtf16be( Bu::Stream &sOut );
+                void writeUtf16le( Bu::Stream &sOut );
+                void writeUtf32( Bu::Stream &sOut );
+                void writeUtf32be( Bu::Stream &sOut );
+                void writeUtf32le( Bu::Stream &sOut );
+
+                Bu::String to( Encoding eEnc=Utf8 );
+                Bu::String toUtf8();
 
                 void debug();
 
                 UtfChar get( int iIndex );
+                UtfChar nextChar( int &iIndex );
 
         private:
                 void append16( uint16_t i ) { aData.append( i ); }