sprint/container/storage_buffer.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::storage_buffer
*
*   Copyright (C) 2005-2011  Paolo Medici <www.pmx.it>
*
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*
*  This library is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*  Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*
*******************************************************************************/

#ifndef _SPRINT_STORAGE_BUFFER_H
#define _SPRINT_STORAGE_BUFFER_H

namespace sprint {

class storage_buffer {
        char * m_str;
        unsigned int m_lenght;
        unsigned int m_capacity;
        public:

        template<class R>
        storage_buffer(R *ptr, unsigned int capacity) : m_str( reinterpret_cast<char *>(ptr) ), m_lenght(0), m_capacity(capacity * sizeof(R) ) {}

        template<class R>
        storage_buffer(const R &buf) : m_str(buf.data()), m_lenght(0), m_capacity(buf.lenght()) {}

        template<class T>
        void insert(const T *a, int len)
        {
      // TODO: check size
                memcpy(&m_str[m_lenght], a, len * sizeof(T));
                m_lenght+=len;
        }

        void push_back(char c)
        {
          m_str[m_lenght] = c;
          m_lenght++;
    }

        inline storage_buffer & operator << (const char *str)
                {
                insert(str, strlen(str) );
                return *this;
                }

        inline storage_buffer & operator << (char c)
                {
        push_back(c);
                return *this;
                }

        template<class T>
        inline storage_buffer & operator << (const T & c)
         {
               insert(reinterpret_cast<char *>(&c), sizeof(c) );
               return *this;
         }
                
        
        inline const char *str() { m_str[m_lenght]=0; return &m_str[0]; }
        
        inline const char *data() const { return &m_str[0]; }

        inline unsigned int size() const { return m_lenght; }

        inline unsigned int lenght() const { return m_lenght; }

        inline unsigned int capacity() const { return m_capacity; }
};

}

#endif