sprint/container/shared_vector.h

Go to the documentation of this file.

/******************************************************************************
*   sprint::shared_vector
*
*   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_SHAREDVECTOR_H
#define _SPRINT_SHAREDVECTOR_H

#include <cstring>
// #include <bits/allocator.h>
#include <memory>

namespace sprint {

template<typename _Tp, typename _Alloc = std::allocator<unsigned char> >
class shared_vector: public _Alloc {
        protected:
        
        // base pointer
    struct _Rep {
      long m_size;      
      long m_capacity;  
      long m_refCount;  
    };

    static const int suggestedSize = (65536 - sizeof(_Rep)/sizeof(_Tp));

    _Tp *m_data;

        // the _Rep info block (where memory begins)
    _Rep *_M_rep() const
      { 
                        return &((reinterpret_cast<_Rep*>(m_data))[-1]); 
          }
        
    // alloc memory using current allocator             
                _Rep *alloc(long size)
                {
                                unsigned char *p = this->allocate( sizeof(_Tp) * size + sizeof(_Rep) );
                                _Rep *r = reinterpret_cast<_Rep*>(p);
                                r->m_capacity = size;
                                r->m_refCount = 1;
                                return r;
                }
                
        // release memory using current allocator
                void release(_Rep *r)
                {
                        if ( (--r->m_refCount) == 0)
                         {
                                this->deallocate( reinterpret_cast<unsigned char*>(r),  r->m_capacity * sizeof(_Tp) + sizeof(_Rep) );                   
             }
                }
                


public:
                shared_vector(long size = suggestedSize ) 
                        { 
                                _Rep * r = alloc(size);
                                r->m_size = 0;
                                m_data = reinterpret_cast<_Tp * >( &r[1] );
                        }
                        
                shared_vector(const shared_vector & s)
                {
                        m_data = s.m_data;
                        ++_M_rep()->m_refCount;
                }
       
        ~shared_vector()
        {
                        release(_M_rep());
                }

        void resize(long new_size)
        {
          reserve(new_size);
                                _M_rep()->m_size = new_size;
                                // TODO: initialize new data
        }

        void reserve(long reserve)
        {
                _Rep *r = _M_rep();
                if(reserve > r->m_capacity)
                        {
                    // TODO: reserve arrotondare a un valore X
                                _Rep *nr = alloc(reserve);
                                nr->m_size = r->m_size;
                                memcpy(&nr[1], &r[1], r->m_size * sizeof(_Tp));
                                release(r);
                                m_data = reinterpret_cast<_Tp *>( &r[1] );
                        }
        }
                
                inline int size() const
                    {  return _M_rep()->m_size;       }  
                
        inline int capacity() const
                    {  return _M_rep()->m_capacity;   }  
                
        inline _Tp & operator[](int i)     
            {  return m_data[i];             }
            
        inline _Tp * begin() { return &m_data[0]; }
        inline const _Tp * begin() const { return &m_data[0]; }
        inline const _Tp * end() const { return &m_data[_M_rep()->m_size]; }
                
                inline const _Tp & operator[](int i) const  
            {  return m_data[i];             }          

         inline bool unique() const      
            {  return  _M_rep()->m_refCount==1;    }
         
     inline long use_count() const      
            {  return  _M_rep()->m_refCount;     }
     
};

}

#endif