be_memory_autobuffer.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_MEMORY_AUTOBUFFER__
#define __BE_MEMORY_AUTOBUFFER__
 
#include <be_error_exception.h>
 
namespace BiometricEvaluation {
 
    namespace Memory {
        template<class T> 
        class AutoBuffer {
        
                public:
                        
                        using value_type = T;
 
                        using reference = T&;
                        using const_reference = const T&;
                
                        operator T*();
                        T* operator->();
 
                        AutoBuffer& operator= (const AutoBuffer& other);
                                        
                        AutoBuffer();
                        /* You already have an allocated buffer */
                        AutoBuffer(T* data);
                        /* Constructor, Destructor, Copy Copy Constructor */
                        AutoBuffer(int (*ctor)(T**), void (*dtor)(T*), 
                            int (*copyCtor)(T**, T*)=nullptr);
                        AutoBuffer(const AutoBuffer& copy);
 
                        ~AutoBuffer();
                                                
                private:
                
                        /* Pointer to allocated data */
                        T* _data;
                        /* Allocator function pointer */
                        int (*_ctor)(T**);
                        /* Destructor function pointer */
                        void (*_dtor)(T*);
                        /* Copy constructor function pointer */
                        int (*_copyCtor)(T**, T*);
                        /* 
                         * True if we passed in preallocated data.  Don't 
                         * perform any memory management, just keep track of
                         * the pointer.
                         */
                        bool _handsOff;
                        
        };
    }
}
 
/******************************************************************************/
/* Implementation.                                                            */
/******************************************************************************/
        
/******************************************************************************/
/* Method implementations.                                                    */
/******************************************************************************/
 
/*
 * Operators.
 */
template<class T>
BiometricEvaluation::Memory::AutoBuffer<T>::operator T*() 
{
        return _data; 
}
 
template<class T>
T* BiometricEvaluation::Memory::AutoBuffer<T>::operator->()
{
        return _data;
}
 
template<class T>
BiometricEvaluation::Memory::AutoBuffer<T>&
BiometricEvaluation::Memory::AutoBuffer<T>::operator=
    (const BiometricEvaluation::Memory::AutoBuffer<T>& copy) 
{
        if (this != &copy) {
                /* Copy function pointers, they aren't changing */
                _ctor = copy._ctor;
                _dtor = copy._dtor;
                _copyCtor = copy._copyCtor;
                _handsOff = copy._handsOff;
        
                if (_handsOff)
                        /* Just copy the pointer */
                        _data = copy._data;
                else {
                        /* 
                         * Use copy constructor on the allocated memory to 
                         * duplicate.
                         */
                        if (_copyCtor == nullptr)
                                throw Error::ParameterError("Copy "
                                    "constructor is nullptr");
                        if ((_copyCtor)(&_data, copy._data) != 0)
                                throw Error::DataError("Data could not be "
                                    "allocated");
                }       
        }
 
        return *this;
}
 
/******************************************************************************/
/* Constructors.                                                              */
/******************************************************************************/
template<class T>
BiometricEvaluation::Memory::AutoBuffer<T>::AutoBuffer()
{
        _data = nullptr;
        _handsOff = true;
}
 
template<class T>
BiometricEvaluation::Memory::AutoBuffer<T>::AutoBuffer(
    int (*ctor)(T**),
    void (*dtor)(T*), 
    int (*copyCtor)(T**, T*)) 
{
        if (ctor != nullptr)
                _ctor = ctor;
        else
                throw Error::ParameterError("Allocator is nullptr");
        
        if (dtor != nullptr)
                _dtor = dtor;
        else
                throw Error::ParameterError("Destructor is nullptr");
                
        /* Don't require copy constructor, user might never make copy */
        _copyCtor = copyCtor;
 
        /* Initial allocation the data */
        if ((_ctor)(&_data) != 0)
                throw Error::DataError("Data could not be allocated");
                
        _handsOff = false;
}
 
template<class T>
BiometricEvaluation::Memory::AutoBuffer<T>::AutoBuffer(T* data) 
{
        /* 
         * With this constructor, the AutoBuffer is essentially nothing more
         * than a bloated pointer.  The caller still must free memory manually.
         * This just allows for uniform usage in classes that can take an 
         * allocated buffer or can create one.
         */
        _data = data;
        _handsOff = true;
}
 
template<class T>
BiometricEvaluation::Memory::AutoBuffer<T>::AutoBuffer(const AutoBuffer& copy) 
{
        /* Copy function pointers, they aren't changing */
        _ctor = copy._ctor;
        _dtor = copy._dtor;
        _copyCtor = copy._copyCtor;
        _handsOff = copy._handsOff;
        
        if (_handsOff)
                /* Just copy the pointer and pray the user hasn't freed it */
                _data = copy._data;
        else {
                /* Use copy constructor on the allocated memory to duplicate */
                if (_copyCtor == nullptr)
                        throw Error::ParameterError("Copy constructor is "
                            "nullptr");
        
                if ((_copyCtor)(&_data, copy._data) != 0)
                        throw Error::DataError("Data could not be "
                            "allocated");
        }
}
 
/******************************************************************************/
/* Destructor.                                                                */
/******************************************************************************/
template<class T>
BiometricEvaluation::Memory::AutoBuffer<T>::~AutoBuffer() 
{
        if (!_handsOff)
                (_dtor)(_data);
}
 
#endif /* __BE_MEMORY_AUTOBUFFER__ */