blRawArrayWrapper.hpp

Go to the documentation of this file.

#ifndef BL_RAWARRAYWRAPPER_HPP
#define BL_RAWARRAYWRAPPER_HPP
 
 
//-------------------------------------------------------------------
// FILE:            blRawArrayWrapper.hpp
// CLASS:           blRawArrayWrapper
// BASE CLASS:      None
//
// PURPOSE:         This class is used to wrap a raw
//                  static or dynamic array with the
//                  basic functionality needed to use
//                  the array with the smart iterators
//                  in the blIteratorAPI library
//
// AUTHOR:          Vincenzo Barbato
//                  http://www.barbatolabs.com
//                  navyenzo@gmail.com
//
// LISENSE:         MIT-LICENCE
//                  http://www.opensource.org/licenses/mit-license.php
//
// DEPENDENCIES:
//
// NOTES:
//
// DATE CREATED:    Mar/20/2014
//
// DATE UPDATED:
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
 
class blRawArrayWrapper
{
public: // Public typedefs
 
    typedef blRawIterator<blDataType>                       iterator;
    typedef blRawIterator<const blDataType>                 const_iterator;
 
    typedef blRawReverseIterator<blDataType>                reverse_iterator;
    typedef blRawReverseIterator<const blDataType>          const_reverse_iterator;
 
public: // Constructors and destructors
 
    // Default constructor
 
    blRawArrayWrapper();
 
    // Copy constructor
 
    blRawArrayWrapper(const blRawArrayWrapper<blDataType>& rawArrayWrapper) = default;
 
    // Move constructor
 
    blRawArrayWrapper(blRawArrayWrapper<blDataType>&& rawArrayWrapper) = default;
 
    // Constructor using
    // a raw static array
 
    template<size_t blArraySize>
    blRawArrayWrapper(blDataType (&rawStaticArray)[blArraySize]);
 
    // Constructor using
    // a raw array
 
    blRawArrayWrapper(blDataType* rawArray,
                      const size_t& arraySize);
 
    // Destructor
 
    ~blRawArrayWrapper()
    {
    }
 
public: // Public functions
 
    // Assignment operator
    // overloads
    blRawArrayWrapper<blDataType>& operator=(const blRawArrayWrapper<blDataType>&) = default;
    blRawArrayWrapper<blDataType>& operator=(blRawArrayWrapper<blDataType>&&) = default;
 
    // Additional operator
    // overloads
 
    bool                                                    operator==(const blRawArrayWrapper<blDataType>& array)const;
    bool                                                    operator!=(const blRawArrayWrapper<blDataType>& array)const;
 
    // Element access
    // functions
 
    blDataType&                                             operator[](const size_t elementIndex);
    const blDataType&                                       operator[](const size_t elementIndex)const;
 
    // Functions used
    // to return the
    // array size
 
    size_t                                                  length()const;
    size_t                                                  size()const;
    size_t                                                  max_size()const;
    bool                                                    empty()const;
 
    // Function used to
    // get the container
    // iterator
 
    const iterator&                                         getContainerIter()const;
    const_iterator                                          getContainerConstIter()const;
 
    // Functions used to
    // get iterators to
    // this container
 
    iterator                                                begin();
    iterator                                                end();
    const_iterator                                          cbegin()const;
    const_iterator                                          cend()const;
 
    reverse_iterator                                        rbegin();
    reverse_iterator                                        rend();
    const_reverse_iterator                                  crbegin()const;
    const_reverse_iterator                                  crend()const;
 
private: // Private variables
 
    // The pointer to the
    // raw array data
 
    iterator                                                m_containerIter;
 
    // The size/length of
    // the raw array
 
    size_t                                                  m_size;
};
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline blRawArrayWrapper<blDataType>::blRawArrayWrapper()
{
    m_size = 0;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
template<size_t blArraySize>
inline blRawArrayWrapper<blDataType>::blRawArrayWrapper(blDataType (&rawStaticArray)[blArraySize])
{
    if(blArraySize > 0)
        m_containerIter = iterator(&rawStaticArray[0]);
 
    m_size = blArraySize;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline blRawArrayWrapper<blDataType>::blRawArrayWrapper(blDataType* rawArray,
                                                        const size_t& arraySize)
{
    m_containerIter = iterator(rawArray);
    m_size = arraySize;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
 
inline const typename blRawArrayWrapper<blDataType>::iterator&
 
blRawArrayWrapper<blDataType>::getContainerIter()const
{
    return m_containerIter;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
 
inline typename blRawArrayWrapper<blDataType>::const_iterator
 
blRawArrayWrapper<blDataType>::getContainerConstIter()const
{
    return m_containerIter;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline bool blRawArrayWrapper<blDataType>::operator==(const blRawArrayWrapper<blDataType>& rawArrayWrapper)const
{
    if(!m_containerIter || !rawArrayWrapper.getContainerIter())
        return false;
 
    if(this == &rawArrayWrapper)
        return true;
 
    auto iter1 = cbegin();
    auto iter2 = rawArrayWrapper.cbegin();
 
    for(;
        iter1 != cend(),iter2 != rawArrayWrapper.cend();
        ++iter1,++iter2)
    {
        if((*iter1) != (*iter2))
            return false;
    }
 
    return true;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline bool blRawArrayWrapper<blDataType>::operator!=(const blRawArrayWrapper<blDataType>& array)const
{
    return !( (*this) == array );
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline blDataType& blRawArrayWrapper<blDataType>::operator[](const size_t elementIndex)
{
    return m_containerIter[elementIndex];
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline const blDataType& blRawArrayWrapper<blDataType>::operator[](const size_t elementIndex)const
{
    return m_containerIter[elementIndex];
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline size_t blRawArrayWrapper<blDataType>::length()const
{
    return m_size;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline size_t blRawArrayWrapper<blDataType>::size()const
{
    return m_size;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline size_t blRawArrayWrapper<blDataType>::max_size()const
{
    return m_size;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
template<typename blDataType>
inline bool blRawArrayWrapper<blDataType>::empty()const
{
    return (m_size != 0);
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
// The iterators
//-------------------------------------------------------------------
template<typename blDataType>
inline typename blRawArrayWrapper<blDataType>::iterator blRawArrayWrapper<blDataType>::begin()
{
    return m_containerIter;
}
 
template<typename blDataType>
inline typename blRawArrayWrapper<blDataType>::iterator blRawArrayWrapper<blDataType>::end()
{
    if(m_containerIter)
        return (m_containerIter + static_cast<ptrdiff_t>(size()));
    else
        return m_containerIter;
}
 
template<typename blDataType>
inline typename blRawArrayWrapper<blDataType>::const_iterator blRawArrayWrapper<blDataType>::cbegin()const
{
    return m_containerIter;
}
 
template<typename blDataType>
inline typename blRawArrayWrapper<blDataType>::const_iterator blRawArrayWrapper<blDataType>::cend()const
{
    if(m_containerIter)
        return (m_containerIter + size());
    else
        return m_containerIter;
}
 
template<typename blDataType>
inline typename blRawArrayWrapper<blDataType>::reverse_iterator blRawArrayWrapper<blDataType>::rbegin()
{
    if(m_containerIter && (size() > 0))
        return reverse_iterator(m_containerIter + static_cast<ptrdiff_t>(size()) - 1);
    else
        return m_containerIter;
}
 
template<typename blDataType>
inline typename blRawArrayWrapper<blDataType>::reverse_iterator blRawArrayWrapper<blDataType>::rend()
{
    if(m_containerIter && (size() > 0))
        return (m_containerIter - 1);
    else
        return m_containerIter;
}
 
template<typename blDataType>
inline typename blRawArrayWrapper<blDataType>::const_reverse_iterator blRawArrayWrapper<blDataType>::crbegin()const
{
    if(m_containerIter && (size() > 0))
        return (m_containerIter + size() - 1);
    else
        return m_containerIter;
}
 
template<typename blDataType>
inline typename blRawArrayWrapper<blDataType>::const_reverse_iterator blRawArrayWrapper<blDataType>::crend()const
{
    if(m_containerIter && (size() > 0))
        return (m_containerIter - 1);
    else
        return m_containerIter;
}
//-------------------------------------------------------------------
 
 
//-------------------------------------------------------------------
// Functions used to easily initialize
// a raw array wrapper
//-------------------------------------------------------------------
template<typename blDataType,size_t blArraySize>
blRawArrayWrapper<blDataType> getRawArrayWrapper(blDataType (&rawStaticArray)[blArraySize])
{
    return blRawArrayWrapper<blDataType>(rawStaticArray);
}
 
template<typename blDataType>
blRawArrayWrapper<blDataType> getRawArrayWrapper(blDataType* rawArray,
                                                 const size_t& arraySize)
{
    return blRawArrayWrapper<blDataType>(rawArray,
                                         arraySize);
}
//-------------------------------------------------------------------
 
 
#endif // BL_RAWARRAYWRAPPER_HPP