PstVector.h

Go to the documentation of this file.

// Copyright PS-Tech B.V. All Rights Reserved.
 
#pragma once
 
#include "PstBase.h"
 
#include <cstddef>
 
namespace PSTech
{
namespace Utils
{
    template<typename T>
    class PST_EXPORT PstVector
    {
    public:
        typedef T value_type;
        typedef size_t size_type;
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T* iterator;
        typedef const T* const_iterator;
 
        PstVector();
 
        explicit PstVector(size_type size);
 
        PstVector(size_type size, const_reference data);
 
        PstVector(const PstVector& vector);
        
        PstVector(PstVector&& vector) noexcept;
 
        ~PstVector();
 
        PstVector& operator=(const PstVector& vector);
        
        PstVector& operator=(PstVector&& vector) noexcept;
 
        void swap(PstVector& vector) noexcept;
 
        size_type size() const;
 
        size_type capacity() const;
 
        bool empty() const;
 
        void reserve(size_type size);
 
        void resize(size_type size);
 
        void resize(size_type size, const_reference data);
 
        void clear();
 
        void assign(size_type count, const_reference data);
 
        void push_back(const_reference data);
 
        void push_back(T&& data);
 
        void pop_back();
 
        const_reference at(size_type index) const;
 
        reference at(size_type index);
 
        const_reference front() const;
 
        reference front();
 
        const_reference back() const;
 
        reference back();
 
        const_iterator cbegin() const;
        
        const_iterator begin() const;
 
        iterator begin();
 
        const_iterator cend() const;
 
        const_iterator end() const;
 
        iterator end();
 
        const_reference operator [] (size_type index) const;
 
        reference operator [] (size_type index);
 
    private:
        class Allocator
        {
        public:
            typename PstVector<T>::pointer allocate(typename PstVector<T>::size_type num);
 
            void construct(typename PstVector<T>::pointer p);
 
            template<class... A>
            void construct(typename PstVector<T>::pointer p, A&... arg);
 
            void construct(typename PstVector<T>::pointer p, T&& data);
 
            /* Destroy elements of initialized storage p */
            void destroy(typename PstVector<T>::pointer p);
 
            /* Deallocate storage p of deleted elements */
            void deallocate(typename PstVector<T>::pointer p);
        };
 
        size_type m_size;
        size_type m_allocated;
        pointer m_array;
        Allocator m_allocator;
 
        void resize_internal(size_type size, const_pointer data);
 
        void check_bounds(size_type index) const;
    };
}
}