TStaticArray.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* 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
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      TStaticArray.h
 *
 * Requires:  
 * - Mbo.h
 */
/* ------------------------------------------------------------------------ */

#ifndef _TSTATICARRAY_H_
#define _TSTATICARRAY_H_

#include "Mbo.h"

#if defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
#endif

namespace mbo
{

#ifndef MBO_TSA_VERIFY
# define MBO_TSA_VERIFY 1
#endif

#ifndef MBO_TSA_STL_ITERATOR
# define MBO_TSA_STL_ITERATOR 1
#endif

#if MBO_TSA_VERIFY
# define mbo_tsa_throw_if_not(exception, condition)  mbo_throw_if_not(exception, condition)
#else
# define mbo_tsa_throw_if_not(exception, condition)
#endif

/* \def __DEPRECATED
 * Postfix increment and decrement are marked as deprecated. However they are
 * used by the microsoft STL so we do not expose this fact to the compiler.
 */
#ifndef __DEPRECATED
# if !MBO_TSA_STL_ITERATOR && !defined(DOXYGEN) && _MSC_VER >= 1300
#  define __DEPRECATED __declspec(deprecated)
# else
#  define __DEPRECATED
# endif
#endif

template<class   __ValueType
        , size_t __MaxSize
        , class  __Allocator  = std::allocator<__ValueType>
        >
class TStaticArray
{
public:
    typedef TStaticArray<__ValueType, __MaxSize>    _MyType;          
    typedef __Allocator                             allocator;        
    typedef typename __Allocator::size_type         size_type;        
    typedef typename __Allocator::value_type        value_type;       
    typedef typename __Allocator::reference         reference;        
    typedef typename __Allocator::const_reference   const_reference;  
    typedef typename __Allocator::pointer           pointer;          
    typedef typename __Allocator::const_pointer     const_pointer;    
    typedef typename __Allocator::difference_type   difference_type;  
    class iterator; // forward declaration

    class const_iterator
#if MBO_TSA_STL_ITERATOR
# if !defined(_MSC_VER) || _MSC_VER >= 1300 || defined(_STLPORT_VERSION)
        : public std::iterator<std::random_access_iterator_tag, value_type, difference_type, const_pointer, const_reference>
# else
        : public std::_Ranit<value_type, difference_type>
# endif
#endif
    {
    public:
        inline const_iterator(const _MyType & array, size_type pos = 0)
            : m_array(array), m_pos(pos)
        {
        }

        inline const_iterator(const const_iterator& oth)
            : m_array(oth.m_array), m_pos(oth.m_pos)
        {
        }

        inline const_iterator(const iterator& oth)
            : m_array(oth.m_array), m_pos(oth.m_pos)
        {
        }

        inline const_reference operator * () const
        {
            return m_array[m_pos];
        }

        inline const_pointer operator -> () const
        {
            return &(operator*());
        }

        inline const_iterator & operator ++ ()
        {
            ++m_pos;
            return *this;
        }

        inline __DEPRECATED const_iterator operator ++ (int)
        {
            /* postfix operator return an unchanged copy prior to the operaration */
            return const_iterator(m_array, m_pos++);
        }

        inline const_iterator & operator -- ()
        {
            --m_pos;
            return *this;
        }

        inline __DEPRECATED const_iterator operator -- (int)
        {
            /* postfix operator return an unchanged copy prior to the operaration */
            return const_iterator(m_array, m_pos--);
        }

        inline bool operator == (const const_iterator &rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return &m_array == &rhs.m_array && m_pos == rhs.m_pos;
        }

        inline bool operator != (const const_iterator &rhs) const
        {
            return !operator == (rhs);
        }

        inline bool operator == (const iterator &rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return &m_array == &rhs.m_array && m_pos == rhs.m_pos;
        }

        inline bool operator != (const iterator &rhs) const
        {
            return !operator == (rhs);
        }

        inline const_iterator & operator = (const const_iterator & rhs)
        {
#if _MSC_VER >= 1300
# pragma push_macro("new")
# undef new
#endif
            new (this) const_iterator(rhs.m_array, rhs.m_pos);
#if _MSC_VER >= 1300
# pragma pop_macro("new")
#endif
            return *this;
        }

        inline const_reference operator [] (size_type nPos) const __THROWS(out_of_range)
        {
            return m_array[nPos];
        }

        inline difference_type operator - (const const_iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos - rhs.m_pos;
        }

        inline const_iterator & operator -= (difference_type diff) __THROWS(logic_error)
        {
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            mbo_tsa_throw_if_not(logic_error, m_pos >= diff);
            m_pos -= diff;
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            return *this;
        }

        inline const_iterator & operator += (difference_type diff) __THROWS(logic_error)
        {
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            mbo_tsa_throw_if_not(logic_error, m_pos + diff >= m_pos && m_pos + diff >= diff && m_pos + diff <= m_array.size());
            m_pos += diff;
#if _MSC_VER >= 1300
# pragma warning(default: 4018)
#endif
            return *this;
        }

        inline const_iterator operator - (difference_type diff) const __THROWS(logic_error)
        {
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            mbo_tsa_throw_if_not(logic_error, m_pos >= diff);
            return const_iterator(m_array, m_pos - diff);
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
        }

        inline const_iterator operator + (difference_type diff) const __THROWS(logic_error)
        {
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            mbo_tsa_throw_if_not(logic_error, m_pos + diff >= m_pos && m_pos + diff >= diff && m_pos + diff <= m_array.size());
            return const_iterator(m_array, m_pos + diff);
#if _MSC_VER >= 1300
# pragma warning(default: 4018)
#endif
        }

        inline bool operator < (const const_iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos < rhs.m_pos;
        }

        inline bool operator > (const const_iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos > rhs.m_pos;
        }

        inline bool operator <= (const const_iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos <= rhs.m_pos;
        }

        inline bool operator >= (const const_iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhsrhs.m_array);
            return m_pos >= rhs.m_pos;
        }

    protected:
        const _MyType &   m_array; 
        size_type         m_pos;   
    };

    class iterator
#if MBO_TSA_STL_ITERATOR
# if !defined(_MSC_VER) || _MSC_VER >= 1300 || defined(_STLPORT_VERSION)
        : public std::iterator<std::random_access_iterator_tag, value_type, difference_type, pointer, reference>
# else
        : public std::_Ranit<value_type, difference_type>
# endif
#endif
    {
    public:
        friend class const_iterator;

        explicit inline iterator(_MyType & array, size_type pos = 0)
            : m_array(array), m_pos(pos)
        {
        }

        inline iterator(const iterator& oth)
            : m_array(oth.m_array), m_pos(oth.m_pos)
        {
        }

        operator const_iterator()
        {
            return const_iterator(m_array, m_pos);
        }

        inline const_reference operator * () const
        {
            return m_array[m_pos];
        }

        inline reference operator * ()
        {
            return m_array[m_pos];
        }

        inline const_pointer operator -> () const
        {
            return &(operator*());
        }

        inline pointer operator -> ()
        {
            return &(operator*());
        }

        inline iterator & operator ++ ()
        {
            ++m_pos;
            return *this;
        }

        inline __DEPRECATED iterator operator ++ (int)
        {
            /* postfix operator return an unchanged copy prior to the operaration */
            return iterator(m_array, m_pos++);
        }

        inline iterator & operator -- ()
        {
            --m_pos;
            return *this;
        }

        inline __DEPRECATED iterator operator -- (int)
        {
            /* postfix operator return an unchanged copy prior to the operaration */
            return iterator(m_array, m_pos--);
        }

        inline bool operator == (const iterator &rhs) const
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos == rhs.m_pos;
        }

        inline bool operator != (const iterator &rhs) const __THROWS(logic_error)
        {
            return !operator == (rhs);
        }

        inline iterator & operator = (const iterator & rhs)
        {
            new (this) iterator(rhs.m_array, rhs.m_pos);
            return *this;
        }

        inline reference operator [] (size_type nPos) __THROWS(out_of_range)
        {
            return m_array[nPos];
        }

        inline const_reference operator [] (size_type nPos) const __THROWS(out_of_range)
        {
            return m_array[nPos];
        }

        inline difference_type operator - (const iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos - rhs.m_pos;
        }

        inline iterator & operator -= (difference_type diff) __THROWS(logic_error)
        {
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            mbo_ta_throw_if_not(logic_error, m_pos >= diff);
            m_pos -= diff;
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            return *this;
        }

        inline iterator & operator += (difference_type diff) __THROWS(logic_error)
        {
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            mbo_tsa_throw_if_not(logic_error, m_pos + diff >= m_pos && m_pos + diff >= diff && m_pos + diff <= m_array.size());
            m_pos += diff;
#if _MSC_VER >= 1300
# pragma warning(default: 4018)
#endif
            return *this;
        }

        inline iterator operator - (difference_type diff) const __THROWS(logic_error)
        {
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            mbo_tsa_throw_if_not(logic_error, m_pos >= diff);
            return iterator(m_array, m_pos - diff);
#if _MSC_VER >= 1300
# pragma warning(default: 4018)
#endif
        }

        inline iterator operator + (difference_type diff) const __THROWS(logic_error)
        {
#if _MSC_VER >= 1300
# pragma warning(disable: 4018) // '>=' : signed/unsigned mismatch
#endif
            mbo_tsa_throw_if_not(logic_error, m_pos + diff >= m_pos && m_pos + diff >= diff && m_pos + diff <= m_array.size());
            return iterator(m_array, m_pos + diff);
#if _MSC_VER >= 1300
# pragma warning(default: 4018)
#endif
        }

        inline bool operator < (const iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos < rhs.m_pos;
        }

        inline bool operator > (const iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos > rhs.m_pos;
        }

        inline bool operator <= (const iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos <= rhs.m_pos;
        }

        inline bool operator >= (const iterator & rhs) const __THROWS(logic_error)
        {
            mbo_tsa_throw_if_not(logic_error, &m_array == &rhs.m_array);
            return m_pos >= rhs.m_pos;
        }

    protected:
        _MyType &         m_array; 
        size_type         m_pos;   
    };

#if MBO_TSA_STL_ITERATOR

# if !defined(_MSC_VER) || _MSC_VER >= 1300
    typedef std::reverse_iterator<iterator> reverse_iterator;
# else
    typedef std::reverse_iterator<iterator, value_type, reference, pointer, difference_type> reverse_iterator;
# endif
                                 

# if !defined(_MSC_VER) || _MSC_VER >= 1300
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
# else
    typedef std::reverse_iterator<const_iterator, value_type, const_reference, const_pointer, difference_type> const_reverse_iterator;
# endif
#endif

    TStaticArray()
        : m_nSize(0)
        , m_acValues(reinterpret_cast<value_array_ref>(m_acData))
        , m_alloc()
    {
    }

    explicit TStaticArray(_IN size_type initial_count)
        : m_nSize(0)
        , m_acValues(reinterpret_cast<value_array_ref>(m_acData))
        , m_alloc()
    {
        mbo_tsa_throw_if_not(out_of_range, initial_count <= __MaxSize);
        while(m_nSize < initial_count)
        {
            append_element();
        }
    }

    TStaticArray(_IN size_type initial_count, _IN const value_type& val)
        : m_nSize(0)
        , m_acValues(reinterpret_cast<value_array_ref>(m_acData))
        , m_alloc()
    {
        mbo_tsa_throw_if_not(out_of_range, initial_count <= __MaxSize);
        while(m_nSize < initial_count)
        {
            append(val);
        }
    }

    ~TStaticArray()
    {
        clear();
    }

    enum { max_size = __MaxSize };

    inline size_type capacity() const
    {
        return max_size;
    }

    inline size_type size() const
    {
        return m_nSize;
    }

    inline resize(size_type nNewSize) throw(overflow_error)
    {
        resize(nNewSize, value_type());
    }

    inline void resize(size_type nNewSize, value_type value) throw(overflow_error)
    {
        if (nNewSize > max_size)
        {
            nNewSize = max_size;
            throw str::overflow_error("New size exceeds maximum size");
        }
        while(size() < nNewSize)
        {
            push_back(value);
        }
        while(size() > nNewSize)
        {
            pop_back();
        }
    }

    inline void limit_size(size_type nNewSize)
    {
        while(size() > nNewSize)
        {
            pop_back();
        }
    }

    inline void reserve(size_type nNewSize) throw(overflow_error)
    {
        mbo_tsa_throw_if_not(overflow_error, nNewSize <= max_size);
    }

    inline bool empty() const
    {
        return size() == 0;
    }

    inline bool full() const
    {
        return size() == max_size;
    }

    inline const_reference at(_IN size_type index) const throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, index < m_nSize);
        return m_acValues[index];
    }

    inline reference at(_IN size_type index) throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, index < m_nSize);
        return m_acValues[index];
    }

    inline const_reference operator[] (_IN size_type index) const throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, index < m_nSize);
        return m_acValues[index];
    }

    inline reference operator[] (_IN size_type index) throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, index < m_nSize);
        return m_acValues[index];
    }

    inline const_reference front() const throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, m_nSize > 0);
        return m_acValues[0];
    }

    inline reference front() throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, m_nSize > 0);
        return m_acValues[0];
    }

    inline const_reference back() const throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, m_nSize > 0);
        return m_acValues[m_nSize-1];
    }

    inline reference back() throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, m_nSize > 0);
        return m_acValues[m_nSize-1];
    }

    inline void push_back(_IN const_reference value) throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, m_nSize < __MaxSize);
        m_alloc.construct(m_alloc.address(m_acValues[m_nSize++]), value);
    }

    inline void pop_back() throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, m_nSize > 0);
        m_alloc.destroy(m_alloc.address(m_acValues[--m_nSize]));
    }

    inline bool append(_IN const_reference value)
    {
        if (m_nSize < max_size)
        {
            m_alloc.construct(m_alloc.address(m_acValues[m_nSize++]), value);
            return true;
        }
        else
        {
            return false;
        }
    }

    inline reference append_element() throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, m_nSize < __MaxSize);
        m_alloc.construct(m_alloc.address(m_acValues[m_nSize]), value_type());
        return m_acValues[m_nSize++];
    }

    inline void clear()
    {
        while(m_nSize)
        {
            m_alloc.destroy(m_alloc.address(m_acValues[--m_nSize]));
        }
    }

    inline const_iterator begin() const
    {
        return const_iterator(*this, 0);
    }

    inline iterator begin()
    {
        return iterator(*this, 0);
    }

    inline const_iterator end() const
    {
        return const_iterator(*this, m_nSize);
    }

    inline iterator end()
    {
        return iterator(*this, m_nSize);
    }

    inline const_iterator final() const
    {
        return const_iterator(*this, max_size);
    }

    inline iterator final()
    {
        return iterator(*this, max_size);
    }

protected:

#if !defined(_MSC_VER) || _MSC_VER >= 1300

    typedef value_type value_array[__MaxSize];

    typedef value_array&  value_array_ref;
#else
    typedef value_type*   value_array_ref;
#endif

    allocator        m_alloc;     
    size_type        m_nSize;     
    value_array_ref  m_acValues;  
private:

    struct value_memory
    {
        char  m_cData[sizeof(value_type)];
    };

    value_memory    m_acData[__MaxSize];
};

template<class   __ValueType
        , size_t __MaxSize
        , class  __Allocator  = std::allocator<__ValueType>
        >
class TStaticArrayEx
    : public TStaticArray<__ValueType, __MaxSize, __Allocator>
{
public:
    inline const_reference operator[] (_IN size_type index) const throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, index < __MaxSize);
        while(m_nSize <= index)
        {
            const_cast<TStaticArrayEx*>(this)->append_element();
        }
        return m_acValues[index];
    }

    inline reference operator[] (_IN size_type index) throw(out_of_range)
    {
        mbo_tsa_throw_if_not(out_of_range, index < __MaxSize);
        while(m_nSize <= index)
        {
            append_element();
        }
        return m_acValues[index];
    }
};

}; // namespace mbo

#if defined(_MSC_VER)
# pragma warning(pop)
#endif

#endif // _TSTATICARRAY_H_

---