sprint/io/bufferize.h

Go to the documentation of this file.

/******************************************************************************
*   SPRINT::bufferize
*
*   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 _BUFFERIZE_H
#define _BUFFERIZE_H

namespace sprint {

class data_buffer {

        struct _Rep {
      int m_size;       
      int m_capacity;   
      int m_pos;                
    };

    inline _Rep *_M_rep() const
      { 
                        return reinterpret_cast<_Rep*>(m_data); 
          }

        unsigned char *m_data;

private:
        data_buffer(const data_buffer & src) { }

public:
        data_buffer(int capacity) { 
                m_data = new unsigned char[ sizeof(_Rep) + capacity ];  
                _M_rep()->m_capacity = capacity;
                _M_rep()->m_pos = 0;
                _M_rep()->m_size = 0;
                }

        ~data_buffer() { delete [] m_data; }
        
        inline int capacity() const { return _M_rep()->m_capacity; }

        inline int size() const { return _M_rep()->m_size; }
        inline void size(int s) { _M_rep()->m_size = s; }

        inline int pos() const { return _M_rep()->m_pos; }
        inline void pos(int p) { _M_rep()->m_pos = p; }
        
        inline void skip(int s) { _M_rep()->m_pos += s; }
        inline int remain() const { return _M_rep()->m_size - _M_rep()->m_pos; }

        inline unsigned char *data() const { return m_data + sizeof(_Rep); }
        inline unsigned char *cur() const { return m_data + sizeof(_Rep) + _M_rep()->m_pos; }

        inline unsigned char peek()     {
                return m_data[sizeof(_Rep) + _M_rep()->m_pos];
        }

        inline unsigned char get()      {
                return m_data[sizeof(_Rep) + _M_rep()->m_pos++];
        }
        inline void put(unsigned char c)        {
                m_data[sizeof(_Rep) + _M_rep()->m_pos] = c;
                _M_rep()->m_pos++;
        }

    inline bool full() const { return _M_rep()->m_pos == _M_rep()->m_capacity; }
    
        inline bool avail() const { return _M_rep()->m_pos<_M_rep()->m_size; }
        
        int write(const unsigned char *src, int len)
        {
        int r = _M_rep()->m_capacity - _M_rep()->m_pos;
        if(r>0)
        {
                        int copiable = std::min(len, r);
                        ::memcpy(cur(), src, copiable);
                        _M_rep()->m_pos += copiable;
                        _M_rep()->m_size = _M_rep()->m_pos; // volendo si potrebbe scrivere ovunque nel buffer
                        return copiable;
        }
        else
        return 0;
    }
    
    int put(char c) 
    {
        int r = _M_rep()->m_capacity - _M_rep()->m_pos;
        if(r>0)
        {
            *cur() = c;

                        _M_rep()->m_pos ++;
                        _M_rep()->m_size = _M_rep()->m_pos; // volendo si potrebbe scrivere ovunque nel buffer
                        return 1;
        }
        else
        return 0;
    }

        int read(unsigned char *dst, int len)
        {
                int r = remain();
                if( r>0 )
                        {
                        int copiable = std::min(len, r);
                        ::memcpy(dst, cur(), copiable);
                        skip(copiable);
                        return copiable;
                        }
                else
                        return 0;
        }



};

template<class T>
class read_buffer : public T {
        data_buffer m_buf;
        
        bool m_valid;

private:
        
        bool underrun()
        {
        int len = T::read( (char *) m_buf.data(), m_buf.capacity() );
        if(len <=0 )
         {
         m_valid = false;
         return false;
         }
         
                m_buf.size (len);
                m_buf.pos(0);
                return true;
        }

        int direct_read(unsigned char *dst, int len)
        {
                int readed = 0;
                while(len>0)
                        {
                                int read = T::read((char *) dst, len);
                                if(read == -1)
                                        return -1;
                                len -= read;
                                dst += read;
                                readed += read;
                        }
                return readed;
        }

    inline bool check_underrun()
    {
                while(!m_buf.avail())
                        {
                        if(!valid())
                                        return false;
                        underrun();
                        }
    return true;
    }
public:
    template<class P>
        read_buffer(const P & p, int capacity) : T(p), m_buf(capacity), m_valid(true) { }
        read_buffer(int capacity) : m_buf(capacity), m_valid(true) { }

        inline bool valid() const { return m_valid && m_buf.size()!=-1; }
        
        int remain() const { return m_buf.remain(); }
        
        int readsome(unsigned char *dst, int len)
        {
                return check_underrun() ? m_buf.read(dst,len) : -1;
        }

        int read(unsigned char *dst, int len)
        {
                int r;
                int p = 0;
                if(!valid())
                                return -1;
                // leggo intanto dal buffer quanto è presente
                r = m_buf.read(dst, len);
                p += r;
                
                if(p<len)
                        {
                        // se sono qua read ha finito il buffer

                        // il dato rimanente da leggere è più piccolo dell'eventuale capacità?
                        if((p-len)<m_buf.capacity())
                                {
                                // underrun non garantisce però che il dato caricato sia esattamente size
                                while(p<len)
                                        {
                                        if(!underrun())
                                                       return p;
                                                       
                                        p += m_buf.read(dst+p,len-p);
                                        }
                                }
                        else
                                {
                                // uso direttamente il buffer fornito dall'utente. 
                                //  E' comunque più grande del buffer interno e risparmio un memcpy
                                p += direct_read(dst+p, len-p);
                                }
                        }
                return p;
        }
        
        // read and disband data
        inline int skip(int n)
    {
           // TODO:
    }
        
        inline int peek()
        {
        return check_underrun() ? m_buf.peek() : -1;        
    }

        inline int get()
        {
        return check_underrun() ? m_buf.get() : -1;        
    }
};

template<class T>
class write_buffer: public T {
      
          data_buffer m_buf; 
          
          bool m_valid;
      
      public:
             
      write_buffer(const T & t, int capacity) : T(t), m_buf(capacity), m_valid(true) { }
      ~write_buffer() { 
                      // empty buffer on exit
                      flush(); 
                      }
      
      bool good() const { return m_valid; }
      
      bool write(const unsigned char *ptr, int n)
      {
          int p=0;
           // if the size of data is greater of buffer capacity buffer will be
           //  bypassed
           if(n > m_buf.capacity())
           {
                flush();
                T::write(ptr, n);
           }
           else
           {
           // sposta i dati nel data_buffer, incrementando
           while(n>0)
            {
            int w = m_buf.write(ptr, n);
            n-=w;
            if(m_buf.full())
             flush();      
            }
           }
          return true;
      }
      
      bool flush()
      {
        if(!m_valid)
            return false;
        if(m_buf.size() > 0)
            {
            int n = m_buf.size();
            unsigned char *src = m_buf.data();
            while(n>0)
                {
                int r = T::write( src, n );
                if(r<=0)
                  {
                  m_valid = false;
                  return false;
                  }
                n -=r;
                src+=r;
                }
            m_buf.size(0);
                m_buf.pos(0);           
            }
         return true;
      }
      
      inline bool put(unsigned char c)
      {
           m_buf.put(c);
           if(m_buf.full())
             flush();      
           return true;
      }       
             
      };

}

#endif