be_memory_autoarray.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.
 */
 
/*
 * Adapted from "c_array" from "The C++ Programming Language" by Bjarne 
 * Stroustrup (ISBN: 0201700735).
 */
 
#ifndef __BE_MEMORY_AUTOARRAY_H__
#define __BE_MEMORY_AUTOARRAY_H__
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <stdexcept>
#include <utility>
#include <vector>
 
#include <be_error_exception.h>
#include <be_memory_autoarrayiterator.h>
 
namespace BiometricEvaluation
{
        namespace Memory
        {
                template<class T> 
                class AutoArray
                {
                        public:
                                using value_type = T;
                                using size_type = size_t;
                                
                                using iterator = AutoArrayIterator<false, T>;
                                using const_iterator =
                                    AutoArrayIterator<true, T>;
 
                                using reference = T&;
                                using const_reference = const T&;
                
                                operator T*();
                                
                                operator const T*()
                                    const;
                
                                reference
                                operator[](
                                    ptrdiff_t index);
                                    
                                const_reference
                                operator[](
                                    ptrdiff_t index)
                                    const;
                                
                                reference
                                at(
                                    ptrdiff_t index);
 
                                const_reference
                                at(
                                    ptrdiff_t index) const;
                                 
                                iterator
                                begin();
 
                                const_iterator
                                begin()
                                    const;
 
                                const_iterator
                                cbegin()
                                    const;
 
                                iterator
                                end();
 
                                const_iterator
                                end()
                                    const;
                                    
                                const_iterator
                                cend()
                                    const;
 
                                size_type
                                size()
                                    const;
 
                                void
                                resize(
                                    size_type new_size,
                                    bool free = false);
                                    
                                void
                                copy(
                                    const T *buffer);
                                    
                                void
                                copy(
                                    const T *buffer,
                                    size_type size);
 
                                std::vector<T>
                                to_vector()
                                    const;
 
                                explicit AutoArray(
                                    size_type size = 0);
 
                                AutoArray(
                                    const AutoArray &copy);
 
                                AutoArray(
                                    AutoArray &&rvalue)
                                    noexcept;
 
                                AutoArray(
                                    std::initializer_list<T> ilist);
 
                                AutoArray&
                                operator=(
                                    const AutoArray &other);
 
                                AutoArray&
                                operator=(
                                    AutoArray &&other)
                                    noexcept(
                                    noexcept(
                                    std::swap(std::declval<value_type&>(),
                                    std::declval<value_type&>()))
                                    &&
                                    noexcept(
                                    std::swap(std::declval<size_type&>(),
                                    std::declval<size_type&>())));
 
                                    
                                ~AutoArray();
                                                                
                        private:
                                value_type *_data;
                                size_type _size;
                                size_type _capacity;
                };
 
                /**************************************************************/
                /* Useful type definitions of an AutoArray of basic types.    */
                /**************************************************************/
                using uint8Array = AutoArray<uint8_t>;
                using uint16Array = AutoArray<uint16_t>;
                using uint32Array = AutoArray<uint32_t>;
 
                template<typename T>
                bool
                operator==(
                    const AutoArray<T> &lhs,
                    const AutoArray<T> &rhs);
 
                template<typename T>
                bool
                operator!=(
                    const AutoArray<T> &lhs,
                    const AutoArray<T> &rhs);
 
                template<typename T>
                bool
                operator<(
                    const AutoArray<T> &lhs,
                    const AutoArray<T> &rhs);
 
                template<typename T>
                bool
                operator<=(
                    const AutoArray<T> &lhs,
                    const AutoArray<T> &rhs);
 
                template<typename T>
                bool
                operator>(
                    const AutoArray<T> &lhs,
                    const AutoArray<T> &rhs);
 
                template<typename T>
                bool
                operator>=(
                    const AutoArray<T> &lhs,
                    const AutoArray<T> &rhs);
        }
}
 
/******************************************************************************/
/* Method implementations.                                                    */
/******************************************************************************/
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::size_type
BiometricEvaluation::Memory::AutoArray<T>::size()
    const 
{ 
        return (_size);
}
 
template<class T>
void
BiometricEvaluation::Memory::AutoArray<T>::resize(
    size_type new_size,
    bool free)
{
        /* If we've already allocated at least new_size space, then bail */
        if (!free && (new_size <= _capacity)) {
                _size = new_size;
                return;
        }
 
        T* new_data = nullptr;
        if (new_size != 0) {
                new_data = new (std::nothrow) T[new_size];
                if (new_data == nullptr)
                        throw Error::MemoryError("Could not allocate data");
        }
 
        /* Copy as much data as will fit into the new buffer */
        std::copy(&_data[0], &_data[((new_size < _size) ? new_size : _size)],
            new_data);
 
        /* Delete the old buffer and assign the new buffer to this object */
        if (_data != nullptr)
                delete [] _data;
        _data = new_data;
        _size = _capacity = new_size;
}
 
template<class T>
void
BiometricEvaluation::Memory::AutoArray<T>::copy(
    const T *buffer)
{
        std::copy(&buffer[0], &buffer[_size], _data);
}
 
template<class T>
void
BiometricEvaluation::Memory::AutoArray<T>::copy(
    const T *buffer,
    size_type size)
{
        this->resize(size);
        std::copy(&buffer[0], &buffer[size], _data);
}
 
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::const_reference
BiometricEvaluation::Memory::AutoArray<T>::at(
    ptrdiff_t index) const
{
        if (index < 0)
                throw std::out_of_range("index");
        if ((size_type)index < _size)
                return (_data[index]);
        
        throw std::out_of_range("index");
}
 
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::reference
BiometricEvaluation::Memory::AutoArray<T>::at(
    ptrdiff_t index)
{
        if (index < 0)
                throw std::out_of_range("index");
        if ((size_type)index < _size)
                return (_data[index]);
        
        throw std::out_of_range("index");
}
 
template<class T>
typename std::vector<T>
BiometricEvaluation::Memory::AutoArray<T>::to_vector()
    const
{
        return {this->cbegin(), this->cend()};
}
 
/******************************************************************************/
/* Conversion Operators.                                                      */
/******************************************************************************/
template<class T>
BiometricEvaluation::Memory::AutoArray<T>::operator T*()
{
        return (_data);
}
 
template<class T>
BiometricEvaluation::Memory::AutoArray<T>::operator const T*()
    const
{
        return (_data);
}
 
/******************************************************************************/
/* Operator Overloads.                                                        */
/******************************************************************************/
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::reference
BiometricEvaluation::Memory::AutoArray<T>::operator[](
    ptrdiff_t index) 
{ 
        return (_data[index]);
}
 
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::const_reference
BiometricEvaluation::Memory::AutoArray<T>::operator[](
    ptrdiff_t index)
    const
{ 
        return (_data[index]);
}
 
template<class T>
BiometricEvaluation::Memory::AutoArray<T>&
BiometricEvaluation::Memory::AutoArray<T>::operator=(
    const BiometricEvaluation::Memory::AutoArray<T> &other)
{
        if (this != &other) {
                _size = _capacity = other._size;
                if (_data != nullptr) {
                        delete [] _data;
                        _data = nullptr;
                }
                if (_size != 0) {
                        _data = new (std::nothrow) T[_size];
                        if (_data == nullptr)
                                throw Error::MemoryError("Could not "
                                    "allocate data");
                        std::copy(&(other._data[0]), &(other._data[_size]),
                            _data);
                }
        }
 
        return (*this);
}
 
template<class T>
BiometricEvaluation::Memory::AutoArray<T>&
BiometricEvaluation::Memory::AutoArray<T>::operator=(
    BiometricEvaluation::Memory::AutoArray<T> &&other)
    noexcept(
    noexcept(
    std::swap(std::declval<value_type&>(), std::declval<value_type&>())) &&
    noexcept(
    std::swap(std::declval<size_type&>(), std::declval<size_type&>())))
{
        using std::swap;
 
        swap(_size, other._size);
        swap(_capacity, other._capacity);
        swap(_data, other._data);
 
        return (*this);
}
 
/******************************************************************************/
/* Iterators.                                                                 */
/******************************************************************************/
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::iterator
BiometricEvaluation::Memory::AutoArray<T>::begin()
{
        return (iterator(this, 0));
}
 
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::const_iterator
BiometricEvaluation::Memory::AutoArray<T>::begin()
    const 
{ 
        return (this->cbegin());
}
 
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::const_iterator
BiometricEvaluation::Memory::AutoArray<T>::cbegin()
    const 
{ 
        return (const_iterator(this, 0));
}
 
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::iterator
BiometricEvaluation::Memory::AutoArray<T>::end() 
{
        if (this->size() > std::numeric_limits<typename BiometricEvaluation::
            Memory::AutoArrayIterator<false, T>::difference_type>::max())
                throw BiometricEvaluation::Error::StrategyError{"AutoArray too "
                    "large to represent end iterator"};
 
        return (iterator(this,
            static_cast<typename BiometricEvaluation::Memory::
	    AutoArrayIterator<false, T>::difference_type>(this->size())));
}
 
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::const_iterator
BiometricEvaluation::Memory::AutoArray<T>::end()
    const 
{
        return (this->cend());
}
 
template<class T>
typename BiometricEvaluation::Memory::AutoArray<T>::const_iterator
BiometricEvaluation::Memory::AutoArray<T>::cend()
    const
{
        if (this->size() > std::numeric_limits<typename BiometricEvaluation::
            Memory::AutoArrayIterator<true, T>::difference_type>::max())
                throw BiometricEvaluation::Error::StrategyError{"AutoArray too "
                    "large to represent end iterator"};
 
        return (const_iterator(this,
            static_cast<typename BiometricEvaluation::Memory::
	    AutoArrayIterator<true, T>::difference_type>(this->size())));
}
 
/******************************************************************************/
/* Constructors.                                                              */
/******************************************************************************/
template<class T>
BiometricEvaluation::Memory::AutoArray<T>::AutoArray(
    size_type size) :
    _data(nullptr),
    _size(size),
    _capacity(size)
{
        if (_size != 0) {
                _data = new (std::nothrow) T[_size];
                if (_data == nullptr)
                        throw Error::MemoryError("Could not allocate data");
        }
}
 
template<class T>
BiometricEvaluation::Memory::AutoArray<T>::AutoArray(
    const AutoArray& copy) :
    _data(nullptr),
    _size(copy._size),
    _capacity(copy._size)
{
        if (_size != 0) {
                _data = new (std::nothrow) T[_size];
                if (_data == nullptr)
                        throw Error::MemoryError("Could not allocate data");
                std::copy(&(copy._data[0]), &(copy._data[_size]), _data);
        }
}
 
template<class T>
BiometricEvaluation::Memory::AutoArray<T>::AutoArray(
    AutoArray &&rvalue)
    noexcept :
    _data(rvalue._data),
    _size(rvalue._size),
    _capacity(rvalue._capacity)
{
        /* Modify for a speedy destruction */
        rvalue._data = nullptr;
        rvalue._capacity = 0;
        rvalue._size = 0;
}
 
template<class T>
BiometricEvaluation::Memory::AutoArray<T>::AutoArray(
    std::initializer_list<T> ilist) : AutoArray(ilist.size())
{
        std::copy(ilist.begin(), ilist.end(), _data);
}
 
/******************************************************************************/
/* Destructor.                                                                */
/******************************************************************************/
template<class T>
BiometricEvaluation::Memory::AutoArray<T>::~AutoArray()
{
        if (_data != nullptr)
                delete [] _data;
}
 
/******************************************************************************/
/* Comparison operators.                                                      */
/******************************************************************************/
 
template<typename T>
bool
BiometricEvaluation::Memory::operator==(
   const typename BiometricEvaluation::Memory::AutoArray<T> &lhs,
   const typename BiometricEvaluation::Memory::AutoArray<T> &rhs)
{
        if (lhs.size() != rhs.size())
                return (false);
 
        return (std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()));
}
 
template<typename T>
bool
BiometricEvaluation::Memory::operator!=(
   const typename BiometricEvaluation::Memory::AutoArray<T> &lhs,
   const typename BiometricEvaluation::Memory::AutoArray<T> &rhs)
{
        return (!(lhs == rhs));
}
 
template<typename T>
bool
BiometricEvaluation::Memory::operator<(
   const typename BiometricEvaluation::Memory::AutoArray<T> &lhs,
   const typename BiometricEvaluation::Memory::AutoArray<T> &rhs)
{
        return (std::lexicographical_compare(lhs.cbegin(), lhs.cend(),
            rhs.cbegin(), rhs.cend()));
}
 
template<typename T>
bool
BiometricEvaluation::Memory::operator<=(
   const typename BiometricEvaluation::Memory::AutoArray<T> &lhs,
   const typename BiometricEvaluation::Memory::AutoArray<T> &rhs)
{
        return (!(rhs < lhs));
}
 
template<typename T>
bool
BiometricEvaluation::Memory::operator>(
   const typename BiometricEvaluation::Memory::AutoArray<T> &lhs,
   const typename BiometricEvaluation::Memory::AutoArray<T> &rhs)
{
        return (rhs < lhs);
}
 
template<typename T>
bool
BiometricEvaluation::Memory::operator>=(
   const typename BiometricEvaluation::Memory::AutoArray<T> &lhs,
   const typename BiometricEvaluation::Memory::AutoArray<T> &rhs)
{
        return (!(lhs < rhs));
}
 
#endif /* __BE_MEMORY_AUTOARRAY_H__ */