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;
    };
}
}