sprint/container/static_buffer.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::static_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_SBUFFER_H
#define _SPRINT_SBUFFER_H

namespace sprint {

template<int t_capacity, class T = char>
class static_buffer {
        T m_str[t_capacity];
        unsigned int m_cur_pos;
        public:
                static_buffer() : m_cur_pos(0) { m_str[0] = 0; }

                static_buffer(const T *a) : m_cur_pos(0)
                { 
                        insert(a);
                }
                static_buffer(const T *a, const T *b)  : m_cur_pos(0)
                { 
                        insert_(a);
                        insert(b);
                }
                static_buffer(const T *a, const T *b, const T *c)  : m_cur_pos(0)
                { 
                        insert_(a);
                        insert_(b);                     
                        insert(c);
                }
                static_buffer(const T *a, const T *b, const T *c, const T *d)  : m_cur_pos(0)
                { 
                        insert_(a);
                        insert_(b);                     
                        insert_(c);
                        insert(d);
                }
                static_buffer(const T *a, const T *b, const T *c, const T *d, const T *e)  : m_cur_pos(0)
                { 
                        insert_(a);
                        insert_(b);                     
                        insert_(c);
                        insert_(d);                     
                        insert(e);
                }

                void insert_(const T *a)
                {
      // TODO: check size
                        int len = strlen(a);
                        memcpy(&m_str[m_cur_pos], a, len * sizeof(T));
                        m_cur_pos+=len;
                }

                void insert(const T *a)
                {
      // TODO: check size
                        int len = strlen(a);
                        memcpy(&m_str[m_cur_pos], a, (len + 1) * sizeof(T) );
                        m_cur_pos+=len;
                }
                
                static_buffer<t_capacity> & operator << (const T *str)
                {
        insert_(str);
        return *this;
        }
                
                inline const char *c_str() const { return &m_str[0]; }

                inline char *str() { return &m_str[0]; }

                inline const char *data() const { return &m_str[0]; }
                inline int lenght() const { return m_cur_pos; }
      
                inline unsigned int size() const { return m_cur_pos; }

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

}

#endif