staticbuffer.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#ifndef __TEXTWOLF_STATIC_BUFFER_HPP__
#define __TEXTWOLF_STATIC_BUFFER_HPP__
#include "textwolf/exception.hpp"
#include <cstddef>
#include <cstring>
#include <cstdlib>
#include <stdexcept>
#include <new>

namespace textwolf {

class StaticBuffer :public throws_exception
{
public:
        explicit StaticBuffer( std::size_t n)
                :m_pos(0),m_size(n),m_ar(0),m_allocated(true),m_overflow(false)
        {
                m_ar = (char*)std::calloc( n, sizeof(char));
                if (!m_ar) throw std::bad_alloc();
        }

        StaticBuffer( char* p, std::size_t n, std::size_t i=0)
                :m_pos(i)
                ,m_size(n)
                ,m_ar(p)
                ,m_allocated(false)
                ,m_overflow(false) {}

        StaticBuffer( const StaticBuffer& o)
                :m_pos(o.m_pos)
                ,m_size(o.m_size)
                ,m_ar(0)
                ,m_allocated(o.m_allocated)
                ,m_overflow(o.m_overflow)
        {
                m_ar = (char*)std::malloc( m_size * sizeof(char));
                if (!m_ar) throw std::bad_alloc();
                std::memcpy( m_ar, o.m_ar, m_size);
        }

        ~StaticBuffer()
        {
                if (m_allocated && m_ar) std::free(m_ar);
        }

        void clear()
        {
                m_pos = 0;
                m_overflow = false;
        }

        void push_back( char ch)
        {
                if (m_pos < m_size)
                {
                        m_ar[m_pos++] = ch;
                }
                else
                {
                        m_overflow = true;
                }
        }

        void append( const char* cc, std::size_t ccsize)
        {
                if (m_pos+ccsize > m_size)
                {
                        m_overflow = true;
                        ccsize = m_size - m_pos;
                }
                std::memcpy( m_ar+m_pos, cc, ccsize);
                m_pos += ccsize;
        }

        std::size_t size() const                {return m_pos;}

        const char* ptr() const                 {return m_ar;}

        void resize( std::size_t n, char c=0)
        {
                if (m_pos>n)
                {
                        m_pos=n;
                }
                else
                {
                        if (m_size<n) n=m_size;
                        while (n>m_pos) push_back(c);
                }
        }

        char operator []( std::size_t ii) const
        {
                if (ii > m_pos) throw exception( DimOutOfRange);
                return m_ar[ii];
        }

        char& at( std::size_t ii) const
        {
                if (ii > m_pos) throw exception( DimOutOfRange);
                return m_ar[ii];
        }

        bool overflow() const                   {return m_overflow;}
private:
        StaticBuffer(){}                        
private:
        std::size_t m_pos;                      
        std::size_t m_size;                     
        char* m_ar;                             
        bool m_allocated;                       
        bool m_overflow;                        
};

}//namespace
#endif