cel_sstring.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_sstring_h_
#define _cel_sstring_h_

#include "cel_types.h"
#include "cel_stringutil.h"
#include <cstring>

namespace Celartem
{
    template<typename T> struct sstring
    {
        T *m_buffer;
        size_t m_size;

        sstring() : m_buffer(NULL), m_size(0) {}

        sstring(size_t size) : m_buffer(NULL)
        {
            allocate(size);
        }

        ~sstring()
        {
            free();
        }

        sstring(const sstring& str) : m_buffer(NULL)
        {
            duplicate(str);
        }

        sstring(const T *str, size_t length = -1) : m_buffer(NULL)
        {
            from_cstr(str, length);
        }

        sstring& operator=(const sstring& str)
        {
            duplicate(str);
            return *this;
        }

        sstring& operator=(const T *str)
        {
            from_cstr(str);
            return *this;
        }

        void from_cstr(const T *str, size_t length = -1)
        {
            if (str == NULL)
            {
                allocate(1);
                m_buffer[0] = 0;
                return;
            }
            size_t l = StringUtil<T>::strlen(str);
            if(length > l)
                length = l;

            allocate(length + 1);
            std::memcpy(m_buffer, str, length);
            m_buffer[length] = 0;
        }

        void duplicate(const sstring& str)
        {
            allocate(str.m_size);
            std::memcpy(m_buffer, str.m_buffer, sizeof(T) * m_size);
        }

        void allocate(size_t size)
        {
            free();
            m_buffer = new T[size];
            m_size = size;
        }

        void free()
        {
            if(m_buffer)
            {
                std::memset(m_buffer, 0, sizeof(T) * m_size);

                // This prevent compilers from stripping the memset above.
                *(volatile char *)m_buffer = *(volatile char *)m_buffer;

                delete[] m_buffer;
                m_buffer = NULL;
                m_size = 0;
            }
        }

        operator const T *() const {return m_buffer;}
        const T *getPtr() const {return m_buffer;}

        operator T *() {return m_buffer;}
        T *getPtr() {return m_buffer;}

        size_t getSize() const {return m_size;}

        T *detach()
        {
            T *t = m_buffer;
            m_buffer = NULL;
            return t;
        }
    };

} // namespace Celartem

#endif // _cel_sstring_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:54 2008.