Add RunScript and implement on all backends. Document and add a very simple unit...

[wxWidgets.git] / include / wx / buffer.h

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index 3be01fee36b5821c0fcab3347dfe843ec4564176..254605edf72ebbd70d8a75288281d605fe232b50 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -38,8 +38,8 @@ struct UntypedBufferData
         NonOwned
     };
 
         NonOwned
     };
 

-    UntypedBufferData(void *str, Kind kind = Owned)
-        : m_str(str), m_ref(1), m_owned(kind == Owned) {}
+    UntypedBufferData(void *str, size_t len, Kind kind = Owned)
+        : m_str(str), m_length(len), m_ref(1), m_owned(kind == Owned) {}

 
     ~UntypedBufferData()
     {
 
     ~UntypedBufferData()
     {


@@ -48,19 +48,16 @@ struct UntypedBufferData
     }
 
     void *m_str;
     }
 
     void *m_str;

+    size_t m_length;

 
 

-    // "short" to have sizeof(Data)=8 on 32bit archs
+    // "short" to have sizeof(Data)=12 on 32bit archs

     unsigned short m_ref;
 
     bool m_owned;
 };
 
     unsigned short m_ref;
 
     bool m_owned;
 };
 

-// this has to be defined inside the DLL (and not e.g. as a static variable
-// inside an inline function) as otherwise MSVC gives link errors when the
-// functions are effectively inlined (i.e. in non-debug build)
-//

 // NB: this is defined in string.cpp and not the (non-existent) buffer.cpp
 // NB: this is defined in string.cpp and not the (non-existent) buffer.cpp

-extern WXDLLIMPEXP_DATA_BASE(UntypedBufferData * const) untypedNullDataPtr;
+WXDLLIMPEXP_BASE UntypedBufferData * GetUntypedNullData();

 
 } // namespace wxPrivate
 
 
 } // namespace wxPrivate
 


@@ -82,21 +79,31 @@ public:
     // Creates "non-owned" buffer, i.e. 'str' is not owned by the buffer
     // and doesn't get freed by dtor. Used e.g. to point to wxString's internal
     // storage.
     // Creates "non-owned" buffer, i.e. 'str' is not owned by the buffer
     // and doesn't get freed by dtor. Used e.g. to point to wxString's internal
     // storage.

-    static const wxScopedCharTypeBuffer CreateNonOwned(const CharType *str)
+    static
+    const wxScopedCharTypeBuffer CreateNonOwned(const CharType *str,
+                                                size_t len = wxNO_LEN)

     {
     {

+        if ( len == wxNO_LEN )
+            len = wxStrlen(str);
+

         wxScopedCharTypeBuffer buf;
         if ( str )
         wxScopedCharTypeBuffer buf;
         if ( str )

-            buf.m_data = new Data(const_cast<CharType*>(str), Data::NonOwned);
+            buf.m_data = new Data(const_cast<CharType*>(str), len, Data::NonOwned);

         return buf;
     }
 
     // Creates "owned" buffer, i.e. takes over ownership of 'str' and frees it
     // in dtor (if ref.count reaches 0).
         return buf;
     }
 
     // Creates "owned" buffer, i.e. takes over ownership of 'str' and frees it
     // in dtor (if ref.count reaches 0).

-    static const wxScopedCharTypeBuffer CreateOwned(const CharType *str)
+    static
+    const wxScopedCharTypeBuffer CreateOwned(CharType *str,
+                                             size_t len = wxNO_LEN )

     {
     {

+        if ( len == wxNO_LEN )
+            len = wxStrlen(str);
+

         wxScopedCharTypeBuffer buf;
         if ( str )
         wxScopedCharTypeBuffer buf;
         if ( str )

-            buf.m_data = new Data(wxStrdup(str));
+            buf.m_data = new Data(str, len);

         return buf;
     }
 
         return buf;
     }
 


@@ -131,13 +138,13 @@ public:
         if ( m_data == GetNullData() )
             return NULL;
 
         if ( m_data == GetNullData() )
             return NULL;
 

-        wxASSERT_MSG( m_data->m_owned, _T("can't release non-owned buffer") );
-        wxASSERT_MSG( m_data->m_ref == 1, _T("can't release shared buffer") );
+        wxASSERT_MSG( m_data->m_owned, wxT("can't release non-owned buffer") );
+        wxASSERT_MSG( m_data->m_ref == 1, wxT("can't release shared buffer") );

 
         CharType * const p = m_data->Get();
 
         wxScopedCharTypeBuffer *self = const_cast<wxScopedCharTypeBuffer*>(this);
 
         CharType * const p = m_data->Get();
 
         wxScopedCharTypeBuffer *self = const_cast<wxScopedCharTypeBuffer*>(this);

-        self->m_data->Set(NULL);
+        self->m_data->Set(NULL, 0);

         self->DecRef();
 
         return p;
         self->DecRef();
 
         return p;


@@ -153,23 +160,29 @@ public:
     operator const CharType *() const { return data(); }
     CharType operator[](size_t n) const { return data()[n]; }
 
     operator const CharType *() const { return data(); }
     CharType operator[](size_t n) const { return data()[n]; }
 

+    size_t length() const { return m_data->m_length; }
+

 protected:
     // reference-counted data
     struct Data : public wxPrivate::UntypedBufferData
     {
 protected:
     // reference-counted data
     struct Data : public wxPrivate::UntypedBufferData
     {

-        Data(CharType *str, Kind kind = Owned)
-            : wxPrivate::UntypedBufferData(str, kind)
+        Data(CharType *str, size_t len, Kind kind = Owned)
+            : wxPrivate::UntypedBufferData(str, len, kind)

         {
         }
 
         CharType *Get() const { return static_cast<CharType *>(m_str); }
         {
         }
 
         CharType *Get() const { return static_cast<CharType *>(m_str); }

-        void Set(CharType *str) { m_str = str; }
+        void Set(CharType *str, size_t len)
+        {
+            m_str = str;
+            m_length = len;
+        }

     };
 
     // placeholder for NULL string, to simplify this code
     static Data *GetNullData()
     {
     };
 
     // placeholder for NULL string, to simplify this code
     static Data *GetNullData()
     {

-        return static_cast<Data *>(wxPrivate::untypedNullDataPtr);
+        return static_cast<Data *>(wxPrivate::GetUntypedNullData());

     }
 
     void IncRef()
     }
 
     void IncRef()


@@ -208,10 +221,21 @@ protected:
             // if the scoped buffer had non-owned data, we have to make
             // a copy here, because src.m_data->m_str is valid only for as long
             // as 'src' exists
             // if the scoped buffer had non-owned data, we have to make
             // a copy here, because src.m_data->m_str is valid only for as long
             // as 'src' exists

-            this->m_data = new Data(wxStrdup(src.m_data->Get()));
+            this->m_data = new Data
+                               (
+                                   StrCopy(src.data(), src.length()),
+                                   src.length()
+                               );

         }
     }
 
         }
     }
 

+    static CharType *StrCopy(const CharType *src, size_t len)
+    {
+        CharType *dst = (CharType*)malloc(sizeof(CharType) * (len + 1));
+        memcpy(dst, src, sizeof(CharType) * (len + 1));
+        return dst;
+    }
+

 protected:
     Data *m_data;
 };
 protected:
     Data *m_data;
 };


@@ -230,17 +254,24 @@ protected:
 public:
     typedef T CharType;
 
 public:
     typedef T CharType;
 

-    wxCharTypeBuffer(const CharType *str = NULL)
+    wxCharTypeBuffer(const CharType *str = NULL, size_t len = wxNO_LEN)

     {
         if ( str )
     {
         if ( str )

-            this->m_data = new Data(wxStrdup(str));
+        {
+            if ( len == wxNO_LEN )
+                len = wxStrlen(str);
+            this->m_data = new Data(this->StrCopy(str, len), len);
+        }

         else
         else

+        {

             this->m_data = this->GetNullData();
             this->m_data = this->GetNullData();

+        }

     }
 
     wxCharTypeBuffer(size_t len)
     {
     }
 
     wxCharTypeBuffer(size_t len)
     {

-        this->m_data = new Data((CharType *)malloc((len + 1)*sizeof(CharType)));
+        this->m_data =
+            new Data((CharType *)malloc((len + 1)*sizeof(CharType)), len);

         this->m_data->Get()[len] = (CharType)0;
     }
 
         this->m_data->Get()[len] = (CharType)0;
     }
 


@@ -252,7 +283,7 @@ public:
         this->DecRef();
 
         if ( str )
         this->DecRef();
 
         if ( str )

-            this->m_data = new Data(wxStrdup(str));
+            this->m_data = new Data(wxStrdup(str), wxStrlen(str));

         return *this;
     }
 
         return *this;
     }
 


@@ -264,7 +295,7 @@ public:
 
     wxCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
     {
 
     wxCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
     {

-        MakeOwnedCopyOf(src);
+        this->MakeOwnedCopyOf(src);

     }
 
     wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer<T>& src)
     }
 
     wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer<T>& src)


@@ -285,18 +316,30 @@ public:
 
         if ( this->m_data == this->GetNullData() )
         {
 
         if ( this->m_data == this->GetNullData() )
         {

-            this->m_data = new Data(str);
+            this->m_data = new Data(str, len);

         }
         else
         {
         }
         else
         {

-            this->m_data->Set(str);
+            this->m_data->Set(str, len);

             this->m_data->m_owned = true;
         }
 
         return true;
     }
             this->m_data->m_owned = true;
         }
 
         return true;
     }

+
+    void shrink(size_t len)
+    {
+        wxASSERT_MSG( this->m_data->m_owned, "cannot shrink non-owned buffer" );
+        wxASSERT_MSG( this->m_data->m_ref == 1, "can't shrink shared buffer" );
+
+        wxASSERT( len <= this->length() );
+
+        this->m_data->m_length = len;
+        this->data()[len] = 0;
+    }

 };
 
 };
 

+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<char> )

 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
 
 class wxCharBuffer : public wxCharTypeBuffer<char>
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
 
 class wxCharBuffer : public wxCharTypeBuffer<char>


@@ -316,7 +359,7 @@ public:
     wxCharBuffer(const wxCStrData& cstr);
 };
 
     wxCharBuffer(const wxCStrData& cstr);
 };
 

-#if wxUSE_WCHAR_T
+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<wchar_t> )

 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
 
 class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
 
 class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>


@@ -335,7 +378,6 @@ public:
 
     wxWCharBuffer(const wxCStrData& cstr);
 };
 
     wxWCharBuffer(const wxCStrData& cstr);
 };

-#endif // wxUSE_WCHAR_T

 
 // wxCharTypeBuffer<T> implicitly convertible to T*
 template <typename T>
 
 // wxCharTypeBuffer<T> implicitly convertible to T*
 template <typename T>


@@ -381,13 +423,6 @@ typedef wxWritableCharTypeBuffer<wchar_t> wxWritableWCharBuffer;
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 
     #define wxWX2WCbuf wxWCharBuffer
 #endif // Unicode/ANSI
 

-// type of the value returned by wxString::utf8_str()
-#if wxUSE_UNICODE_UTF8
-    #define wxUTF8Buf char *
-#else
-    #define wxUTF8Buf wxCharBuffer
-#endif
-

 // ----------------------------------------------------------------------------
 // A class for holding growable data buffers (not necessarily strings)
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // A class for holding growable data buffers (not necessarily strings)
 // ----------------------------------------------------------------------------


@@ -433,6 +468,21 @@ private:
             delete this;
     }
 
             delete this;
     }
 

+    void *release()
+    {
+        if ( m_data == NULL )
+            return NULL;
+
+        wxASSERT_MSG( m_ref == 1, "can't release shared buffer" );
+
+        void *p = m_data;
+        m_data = NULL;
+        m_len =
+        m_size = 0;
+
+        return p;
+    }
+

 
     // the buffer containing the data
     void  *m_data;
 
     // the buffer containing the data
     void  *m_data;


@@ -520,7 +570,7 @@ public:
     // Other ways to append to the buffer
     void  AppendByte(char data)
     {
     // Other ways to append to the buffer
     void  AppendByte(char data)
     {

-        wxCHECK_RET( m_bufdata->m_data, _T("invalid wxMemoryBuffer") );
+        wxCHECK_RET( m_bufdata->m_data, wxT("invalid wxMemoryBuffer") );

 
         m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1);
         *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data;
 
         m_bufdata->ResizeIfNeeded(m_bufdata->m_len + 1);
         *(((char*)m_bufdata->m_data) + m_bufdata->m_len) = data;


@@ -535,6 +585,13 @@ public:
 
     operator const char *() const { return (const char*)GetData(); }
 
 
     operator const char *() const { return (const char*)GetData(); }
 

+    // gives up ownership of data, returns the pointer; after this call,
+    // data isn't freed by the buffer and its content is resent to empty
+    void *release()
+    {
+        return m_bufdata->release();
+    }
+

 private:
     wxMemoryBufferData*  m_bufdata;
 };
 private:
     wxMemoryBufferData*  m_bufdata;
 };