source: source/ariba/utility/transport/messages/shared_buffer.hpp@ 12755

//-----------------------------------------------------------------------------

// Part of reboost (http://reboost.org).  Released under the

// BSD 2-clause license (http://www.opensource.org/licenses/bsd-license.php).

// Copyright 2012, Sebastian Mies <mies@reboost.org> --- All rights reserved.

//-----------------------------------------------------------------------------



#ifndef REBOOST_SHARED_BUFFER_HPP_

#define REBOOST_SHARED_BUFFER_HPP_



#include <cstring>

#include <string>

#include <boost/shared_ptr.hpp>



#include "ariba/config.h"

#ifdef DEBUG

#include <boost/thread/mutex.hpp>

#endif



#include "buffer.hpp"



#include <stdexcept> 



namespace reboost {



class illegal_sub_buffer: public std::runtime_error

{

public:

    /** Takes a character string describing the error.  */

    explicit illegal_sub_buffer(const std::string& __arg)  :

        std::runtime_error(__arg)

    {

    }

    

    virtual ~illegal_sub_buffer() throw() {}

};



/**

 * A simple shared buffer.

 *

 * Important: if not shared, a buffer is writable. After the buffer is shared,

 * the buffer is immutable. It uses shared_ptr/default allocators and prints

 * error messages to <tt>cerr</tt> if buffers leaked at the end of the

 * program.

 *

 * @author Sebastian Mies <mies@reboost.org>

 */

class shared_buffer_t: public buffer_t {

        typedef shared_buffer_t self;

private:

        static void onexit();

        static size_t init();

        

#ifdef DEBUG

        static size_t allocated_buffers;

        static boost::mutex allocated_buffers_mutex;

#endif



        class deleteable_buffer: public buffer_t {

        public:

                deleteable_buffer(bsize_t size) :

                        buffer_t(size)

                {

                        

#ifdef DEBUG

                        boost::mutex::scoped_lock lock(allocated_buffers_mutex);

                        allocated_buffers++;

#endif

                        

                }

                

                deleteable_buffer(boctet_t* data, bsize_t size) :

                        buffer_t(size, data)

                {

                        

#ifdef DEBUG

                        boost::mutex::scoped_lock lock(allocated_buffers_mutex);

                        allocated_buffers++;

#endif

                        

                }

                

                ~deleteable_buffer() {

                        if (!is_null()) delete[] data_;

                        

#ifdef DEBUG

                        boost::mutex::scoped_lock lock(allocated_buffers_mutex);

                        allocated_buffers--;

#endif

                        

                }

        };

        boost::shared_ptr<deleteable_buffer> parent;



public:

        /// create null-buffer

        inline shared_buffer_t() :

                buffer_t(), parent() {

        }



        /// create a shared buffer of a specific size

        inline shared_buffer_t(bsize_t size) :

                buffer_t(), parent(new deleteable_buffer(size)) {

                buffer_t::operator=(*parent);

        }



        /// create shared buffer from string

        inline shared_buffer_t(const char* string) :

                buffer_t(), parent() {

                parent.reset(new deleteable_buffer(strlen(string)));

                memcpy(parent->mutable_data(),string,parent->size());

                data(parent->mutable_data()); size(parent->size());

        }



        /// create shared buffer from buffer

        /// ----> ALTERED BEHAVIOUR:

        /// ----> This constructor transfers ownership rater than copying the data.

        inline shared_buffer_t(boctet_t* buffer, bsize_t size) :

                buffer_t(size, buffer),

                parent(new deleteable_buffer(buffer, size))

        {

        }



//    /// XXX debug... copy!

//      /// create shared buffer from buffer

//      inline shared_buffer_t(const char* buffer, bsize_t size) :

//              buffer_t(), parent(new deleteable_buffer(size)) {

//              memcpy(parent->mutable_data(), buffer, parent->size());

//              data(parent->mutable_data()); this->size(parent->size());

//      }



        /// clone data from a normal buffer

        inline shared_buffer_t(const buffer_t& rhs) :

                buffer_t(), parent(new deleteable_buffer(rhs.size())) {

                buffer_t::operator=(*parent);

                rhs.copy_to(*parent, 0);

        }



        /// copy constructor

        inline shared_buffer_t(const self& rhs) :

                buffer_t(rhs), parent(rhs.parent) {

        }



        /// copy a buffer pointer and size.

        inline self& operator=(const self& rhs) {

                parent = rhs.parent;

                buffer_t::operator=(rhs);

                return (*this);

        }



        /// return sub-buffer.

        inline self operator()(bsize_t index, bsize_t size = 0) const

        {

            // special cases

            if ( index + size > size_ )

            {

                // empty sub-buffer

            if ( index == size_ )

            {

                self n;

                return n;

            }

         

            // ERROR: index out of bounds

            throw illegal_sub_buffer("Index or size out of bounds in shared_buffer"); 

            }



            // regular case

                self n(*this);

                n.data_ += index;

                if (size == 0) n.size_ -= index;

                else n.size_ = size;

                return (n);

        }



        /// returns the number of references

        inline size_t use_count() const {

                return (parent.use_count());

        }



        /// returns true, if this is root buffer

        inline bool is_root() const {

                return ((parent.get() != NULL) && (this->data() == parent->data()) && (

                                this->size() == parent->size()));

        }



        /// returns true, if the buffer is not shared

        inline bool is_unique() const {

                return parent.unique();

        }



        /// makes the buffer unique / not shared by copying the contents

        inline void make_unique() {

                if (is_unique()) return;

                boost::shared_ptr<deleteable_buffer> old = parent;

                parent.reset(new deleteable_buffer(old->size()));

                buffer_t::data(parent->mutable_data());

                old->copy_to(*parent,0);

        }



        /// resize the shared buffer (and make unique)

        inline void resize( bsize_t new_size ) {

                boost::shared_ptr<deleteable_buffer> old = parent;

                parent.reset(new deleteable_buffer(new_size));

                buffer_t::data(parent->mutable_data());

                (*old)(0,new_size).copy_to(*parent,0);

                size_ = new_size;

        }



        /// returns a pointer to mutable data, if shared_buffer is not shared yet.

        inline boctet_t * mutable_data() {

                assert(parent.unique());

                return buffer_t::mutable_data();

        }



        /// drop reference to buffer

        inline void reset() {

                parent.reset();

                data(NULL);

                size(0);

        }



        /// concatenate buffers

        self operator+( const buffer_t& rhs ) const {

                self nb(size()+rhs.size());

                this->copy_to(nb,0);

                rhs.copy_to(nb,size());

                return nb;

        }

};



} /* namespace reboost */



#endif /* REBOOST_SHARED_BUFFER_HPP_ */