No changes, just simplify preprocessor checks in wxMSW wxTextEntry.

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

diff --git a/include/wx/buffer.h b/include/wx/buffer.h
index 32443237373ac92b4429d53f69cfe227f3dac051..254605edf72ebbd70d8a75288281d605fe232b50 100644 (file)
--- a/include/wx/buffer.h
+++ b/include/wx/buffer.h
@@ -26,35 +26,106 @@ class WXDLLIMPEXP_FWD_BASE wxCStrData;
 // of new/delete
 // ----------------------------------------------------------------------------
 
 // of new/delete
 // ----------------------------------------------------------------------------
 

+// helpers used by wxCharTypeBuffer
+namespace wxPrivate
+{
+
+struct UntypedBufferData
+{
+    enum Kind
+    {
+        Owned,
+        NonOwned
+    };
+
+    UntypedBufferData(void *str, size_t len, Kind kind = Owned)
+        : m_str(str), m_length(len), m_ref(1), m_owned(kind == Owned) {}
+
+    ~UntypedBufferData()
+    {
+        if ( m_owned )
+            free(m_str);
+    }
+
+    void *m_str;
+    size_t m_length;
+
+    // "short" to have sizeof(Data)=12 on 32bit archs
+    unsigned short m_ref;
+
+    bool m_owned;
+};
+
+// NB: this is defined in string.cpp and not the (non-existent) buffer.cpp
+WXDLLIMPEXP_BASE UntypedBufferData * GetUntypedNullData();
+
+} // namespace wxPrivate
+
+
+// Reference-counted character buffer for storing string data. The buffer
+// is only valid for as long as the "parent" object that provided the data
+// is valid; see wxCharTypeBuffer<T> for persistent variant.

 template <typename T>
 template <typename T>

-class WXDLLIMPEXP_BASE wxCharTypeBuffer
+class wxScopedCharTypeBuffer

 {
 public:
     typedef T CharType;
 
 {
 public:
     typedef T CharType;
 

-    wxCharTypeBuffer(const CharType *str = NULL)
+    wxScopedCharTypeBuffer()

     {
     {

-        if ( str )
-            m_data = new Data(wxStrdup(str));
-        else
-            m_data = &NullData;
+        m_data = GetNullData();

     }
 
     }
 

-    wxCharTypeBuffer(size_t len)
+    // 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,
+                                                size_t len = wxNO_LEN)

     {
     {

-        m_data = new Data((CharType *)malloc((len + 1)*sizeof(CharType)));
-        m_data->m_str[len] = (CharType)0;
+        if ( len == wxNO_LEN )
+            len = wxStrlen(str);
+
+        wxScopedCharTypeBuffer buf;
+        if ( str )
+            buf.m_data = new Data(const_cast<CharType*>(str), len, Data::NonOwned);
+        return buf;

     }
 
     }
 

-    static const wxCharTypeBuffer CreateNonOwned(const CharType *str)
+    // Creates "owned" buffer, i.e. takes over ownership of 'str' and frees it
+    // in dtor (if ref.count reaches 0).
+    static
+    const wxScopedCharTypeBuffer CreateOwned(CharType *str,
+                                             size_t len = wxNO_LEN )

     {
     {

-        wxCharTypeBuffer buf;
+        if ( len == wxNO_LEN )
+            len = wxStrlen(str);
+
+        wxScopedCharTypeBuffer buf;

         if ( str )
         if ( str )

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

         return buf;
     }
 
         return buf;
     }
 

-    ~wxCharTypeBuffer()
+    wxScopedCharTypeBuffer(const wxScopedCharTypeBuffer& src)
+    {
+        m_data = src.m_data;
+        IncRef();
+    }
+
+    wxScopedCharTypeBuffer& operator=(const wxScopedCharTypeBuffer& src)
+    {
+        if ( &src == this )
+            return *this;
+
+        DecRef();
+        m_data = src.m_data;
+        IncRef();
+
+        return *this;
+    }
+
+    ~wxScopedCharTypeBuffer()

     {
         DecRef();
     }
     {
         DecRef();
     }


@@ -64,16 +135,16 @@ public:
     //     that ref-counting is used, it's not really needed.
     CharType *release() const
     {
     //     that ref-counting is used, it's not really needed.
     CharType *release() const
     {

-        if ( m_data == &NullData )
+        if ( m_data == GetNullData() )

             return NULL;
 
             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 *p = m_data->m_str;
+        CharType * const p = m_data->Get();

 
 

-        wxCharTypeBuffer *self = wx_const_cast(wxCharTypeBuffer*, this);
-        self->m_data->m_str = NULL;
+        wxScopedCharTypeBuffer *self = const_cast<wxScopedCharTypeBuffer*>(this);
+        self->m_data->Set(NULL, 0);

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


@@ -84,128 +155,203 @@ public:
         DecRef();
     }
 
         DecRef();
     }
 

-    wxCharTypeBuffer(const wxCharTypeBuffer& src)
+    CharType *data() { return m_data->Get(); }
+    const CharType *data() const { return  m_data->Get(); }
+    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

     {
     {

-        m_data = src.m_data;
-        IncRef();
+        Data(CharType *str, size_t len, Kind kind = Owned)
+            : wxPrivate::UntypedBufferData(str, len, kind)
+        {
+        }
+
+        CharType *Get() const { return static_cast<CharType *>(m_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()
+    {
+        return static_cast<Data *>(wxPrivate::GetUntypedNullData());
+    }
+
+    void IncRef()
+    {
+        if ( m_data == GetNullData() ) // exception, not ref-counted
+            return;
+        m_data->m_ref++;
+    }
+
+    void DecRef()
+    {
+        if ( m_data == GetNullData() ) // exception, not ref-counted
+            return;
+        if ( --m_data->m_ref == 0 )
+            delete m_data;
+        m_data = GetNullData();
+    }
+
+    // sets this object to a be copy of 'other'; if 'src' is non-owned,
+    // a deep copy is made and 'this' will contain new instance of the data
+    void MakeOwnedCopyOf(const wxScopedCharTypeBuffer& src)
+    {
+        this->DecRef();
+
+        if ( src.m_data == this->GetNullData() )
+        {
+            this->m_data = this->GetNullData();
+        }
+        else if ( src.m_data->m_owned )
+        {
+            this->m_data = src.m_data;
+            this->IncRef();
+        }
+        else
+        {
+            // 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
+                               (
+                                   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;
+};
+
+typedef wxScopedCharTypeBuffer<char> wxScopedCharBuffer;
+typedef wxScopedCharTypeBuffer<wchar_t> wxScopedWCharBuffer;
+
+
+// this buffer class always stores data in "owned" (persistent) manner
+template <typename T>
+class wxCharTypeBuffer : public wxScopedCharTypeBuffer<T>
+{
+protected:
+    typedef typename wxScopedCharTypeBuffer<T>::Data Data;
+
+public:
+    typedef T CharType;
+
+    wxCharTypeBuffer(const CharType *str = NULL, size_t len = wxNO_LEN)
+    {
+        if ( str )
+        {
+            if ( len == wxNO_LEN )
+                len = wxStrlen(str);
+            this->m_data = new Data(this->StrCopy(str, len), len);
+        }
+        else
+        {
+            this->m_data = this->GetNullData();
+        }
+    }
+
+    wxCharTypeBuffer(size_t len)
+    {
+        this->m_data =
+            new Data((CharType *)malloc((len + 1)*sizeof(CharType)), len);
+        this->m_data->Get()[len] = (CharType)0;
+    }
+
+    wxCharTypeBuffer(const wxCharTypeBuffer& src)
+        : wxScopedCharTypeBuffer<T>(src) {}
+

     wxCharTypeBuffer& operator=(const CharType *str)
     {
     wxCharTypeBuffer& operator=(const CharType *str)
     {

-        DecRef();
+        this->DecRef();

 
         if ( str )
 
         if ( str )

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

         return *this;
     }
 
     wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
     {
         return *this;
     }
 
     wxCharTypeBuffer& operator=(const wxCharTypeBuffer& src)
     {

-        if ( &src == this )
-            return *this;
+        wxScopedCharTypeBuffer<T>::operator=(src);
+        return *this;
+    }

 
 

-        DecRef();
-        m_data = src.m_data;
-        IncRef();
+    wxCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)
+    {
+        this->MakeOwnedCopyOf(src);
+    }

 
 

+    wxCharTypeBuffer& operator=(const wxScopedCharTypeBuffer<T>& src)
+    {
+        MakeOwnedCopyOf(src);

         return *this;
     }
 
     bool extend(size_t len)
     {
         return *this;
     }
 
     bool extend(size_t len)
     {

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

 
         CharType *str =
 
         CharType *str =

-            (CharType *)realloc(data(), (len + 1) * sizeof(CharType));
+            (CharType *)realloc(this->data(), (len + 1) * sizeof(CharType));

         if ( !str )
             return false;
 
         if ( !str )
             return false;
 

-        if ( m_data == &NullData )
+        if ( this->m_data == this->GetNullData() )

         {
         {

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

         }
         else
         {
         }
         else
         {

-            m_data->m_str = str;
-            m_data->m_owned = true;
+            this->m_data->Set(str, len);
+            this->m_data->m_owned = true;

         }
 
         return true;
     }
 
         }
 
         return true;
     }
 

-    CharType *data() { return m_data->m_str; }
-    const CharType *data() const { return  m_data->m_str; }
-    operator const CharType *() const { return data(); }
-    CharType operator[](size_t n) const { return data()[n]; }
-
-private:
-    // reference-counted data
-    struct Data
+    void shrink(size_t len)

     {
     {

-        enum Kind
-        {
-            Owned,
-            NonOwned
-        };
-
-        Data(CharType *str, Kind kind = Owned)
-            : m_str(str), m_ref(1), m_owned(kind == Owned) {}
+        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" );

 
 

-        ~Data()
-        {
-            if ( m_owned )
-                free(m_str);
-        }
-
-        CharType *m_str;
-
-        // "short" to have sizeof(Data)=8 on 32bit archs
-        unsigned short m_ref;
-
-        bool m_owned;
-    };
+        wxASSERT( len <= this->length() );

 
 

-    // placeholder for NULL string, to simplify this code
-    // NB: this is defined in string.cpp, not (non-existent) buffer.cpp
-#ifdef __MINGW32__
-    // MinGW requires explicit WXDLLIMPEXP_DATA_BASE to avoid compilation
-    // errors
-    static WXDLLIMPEXP_DATA_BASE(Data) NullData;
-#else
-    // but Visual C++ doesn't like it
-    static Data NullData;
-#endif
-
-    void IncRef()
-    {
-        if ( m_data == &NullData ) // exception, not ref-counted
-            return;
-        m_data->m_ref++;
+        this->m_data->m_length = len;
+        this->data()[len] = 0;

     }
     }

-
-    void DecRef()
-    {
-        if ( m_data == &NullData ) // exception, not ref-counted
-            return;
-        if ( --m_data->m_ref == 0 )
-            delete m_data;
-        m_data = &NullData;
-    }
-
-private:
-    Data *m_data;

 };
 
 };
 

+WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxScopedCharTypeBuffer<char> )

 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
 
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<char> )
 

-class WXDLLIMPEXP_BASE wxCharBuffer : public wxCharTypeBuffer<char>
+class wxCharBuffer : public wxCharTypeBuffer<char>

 {
 public:
     typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;
 {
 public:
     typedef wxCharTypeBuffer<char> wxCharTypeBufferBase;

+    typedef wxScopedCharTypeBuffer<char> wxScopedCharTypeBufferBase;

 
     wxCharBuffer(const wxCharTypeBufferBase& buf)
         : wxCharTypeBufferBase(buf) {}
 
     wxCharBuffer(const wxCharTypeBufferBase& buf)
         : wxCharTypeBufferBase(buf) {}

+    wxCharBuffer(const wxScopedCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}

 
     wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
     wxCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}


@@ -213,35 +359,39 @@ 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> )
 
 WXDLLIMPEXP_TEMPLATE_INSTANCE_BASE( wxCharTypeBuffer<wchar_t> )
 

-class WXDLLIMPEXP_BASE wxWCharBuffer : public wxCharTypeBuffer<wchar_t>
+class wxWCharBuffer : public wxCharTypeBuffer<wchar_t>

 {
 public:
     typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;
 {
 public:
     typedef wxCharTypeBuffer<wchar_t> wxCharTypeBufferBase;

+    typedef wxScopedCharTypeBuffer<wchar_t> wxScopedCharTypeBufferBase;

 
     wxWCharBuffer(const wxCharTypeBufferBase& buf)
         : wxCharTypeBufferBase(buf) {}
 
     wxWCharBuffer(const wxCharTypeBufferBase& buf)
         : wxCharTypeBufferBase(buf) {}

+    wxWCharBuffer(const wxScopedCharTypeBufferBase& buf)
+        : wxCharTypeBufferBase(buf) {}

 
     wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
     wxWCharBuffer(const wxCStrData& cstr);
 };
 
     wxWCharBuffer(const CharType *str = NULL) : wxCharTypeBufferBase(str) {}
     wxWCharBuffer(size_t len) : wxCharTypeBufferBase(len) {}
 
     wxWCharBuffer(const wxCStrData& cstr);
 };

-#endif // wxUSE_WCHAR_T

 
 // wxCharTypeBuffer<T> implicitly convertible to T*
 template <typename T>
 class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
 {
 public:
 
 // wxCharTypeBuffer<T> implicitly convertible to T*
 template <typename T>
 class wxWritableCharTypeBuffer : public wxCharTypeBuffer<T>
 {
 public:

-    typedef typename wxCharTypeBuffer<T>::CharType CharType;
+    typedef typename wxScopedCharTypeBuffer<T>::CharType CharType;

 
 

-    wxWritableCharTypeBuffer(const wxCharTypeBuffer<T>& src)
+    wxWritableCharTypeBuffer(const wxScopedCharTypeBuffer<T>& src)

         : wxCharTypeBuffer<T>(src) {}
     // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
     //             always return a buffer
         : wxCharTypeBuffer<T>(src) {}
     // FIXME-UTF8: this won't be needed after converting mb_str()/wc_str() to
     //             always return a buffer

+    //             + we should derive this class from wxScopedCharTypeBuffer
+    //               then

     wxWritableCharTypeBuffer(const CharType *str = NULL)
         : wxCharTypeBuffer<T>(str) {}
 
     wxWritableCharTypeBuffer(const CharType *str = NULL)
         : wxCharTypeBuffer<T>(str) {}
 


@@ -273,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)
 // ----------------------------------------------------------------------------


@@ -325,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;


@@ -338,11 +496,11 @@ private:
     // the reference count
     size_t m_ref;
 
     // the reference count
     size_t m_ref;
 

-    DECLARE_NO_COPY_CLASS(wxMemoryBufferData)
+    wxDECLARE_NO_COPY_CLASS(wxMemoryBufferData);

 };
 
 
 };
 
 

-class WXDLLIMPEXP_BASE wxMemoryBuffer
+class wxMemoryBuffer

 {
 public:
     // ctor and dtor
 {
 public:
     // ctor and dtor


@@ -412,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;


@@ -427,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;
 };