RandomAccessContainer.h

Go to the documentation of this file.

 
#ifndef RANDOM_ACCESS_CONTAINER_H
#define RANDOM_ACCESS_CONTAINER_H
 
#include "STLBuffer.h"
#include "functional_base.h"
#include "type_traits.h"
#include "Platform.h"

 
namespace dyno {
    template <typename T>
    class RandomAccessContainer : public STLBuffer<T>
    {
        typedef STLBuffer<T>                        base_type;
        typedef RandomAccessContainer<T>            this_type;
 
    public:
        typedef T                                  value_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;   
        typedef long long                           difference_type;
        typedef uint                                size_type;
 
    public:
        DYN_FUNC RandomAccessContainer() = default;
 
        DYN_FUNC RandomAccessContainer(const this_type& c) :
            m_size(c.m_size),
            m_Begin(c.m_Begin),
            m_End(c.m_End),
            m_bufferEnd(c.m_bufferEnd) {
            this->reserve(c.m_startLoc, c.m_maxSize);
        };
 
        DYN_FUNC ~RandomAccessContainer() {
            m_startLoc = nullptr;
            m_Begin = nullptr;
            m_End = nullptr;
            m_bufferEnd = nullptr;
        };
 
        DYN_FUNC void assign(size_type n, const value_type& value);
 
        template <typename InputIterator>
        DYN_FUNC void assign(InputIterator first, InputIterator last);
 
        DYN_FUNC inline iterator       begin() noexcept { return m_Begin; }
        DYN_FUNC inline const_iterator begin() const noexcept { return m_Begin; }
 
        DYN_FUNC inline iterator       end() noexcept {return m_End; }
        DYN_FUNC inline const_iterator end() const noexcept { return m_End; }
 
        DYN_FUNC inline bool      empty() const noexcept {return m_startLoc == nullptr;} //different from std's
        DYN_FUNC inline size_type size() const noexcept { return m_size; }
        DYN_FUNC inline size_type capacity() const noexcept { return m_maxSize; }
 
        DYN_FUNC void resize(size_type n);
 
        DYN_FUNC inline void reserve(iterator beg, size_type buffer_size); //only and must call one time.
        DYN_FUNC inline void reserve(iterator beg, iterator end, size_type buffer_size = 0);
    
        DYN_FUNC inline pointer       data() noexcept { return m_startLoc; }
        DYN_FUNC inline const_pointer data() const noexcept {return m_startLoc; }
 
        DYN_FUNC inline reference       operator[](size_type n);
        DYN_FUNC inline const_reference operator[](size_type n) const;
 
        DYN_FUNC inline reference       at(size_type n);
        DYN_FUNC inline const_reference at(size_type n) const;
 
        DYN_FUNC inline reference       front();
        DYN_FUNC inline const_reference front() const;
 
        DYN_FUNC inline reference       back();
        DYN_FUNC inline const_reference back() const;
 
        DYN_FUNC void      push_back(const value_type& value);
        DYN_FUNC void      push_back(value_type&& value);
        DYN_FUNC reference push_back();
        DYN_FUNC void      pop_back();
 
        DYN_FUNC inline iterator  find(iterator first, iterator last, const value_type& value); //O(n)
 
        template<typename Predicate = dyno::predicate<value_type>>
        DYN_FUNC inline iterator  find(iterator first, iterator last, const value_type& value, Predicate pre); //O(n)
 
        DYN_FUNC iterator insert(const_iterator position, const value_type& value);
        DYN_FUNC iterator insert(const_iterator position, size_type n, const value_type& value);
        DYN_FUNC iterator insert(const_iterator position, value_type&& value);
 
        template <typename InputIterator>
        DYN_FUNC iterator insert(const_iterator position, InputIterator first, InputIterator last);
 
        DYN_FUNC iterator erase_first(const T& value);
        DYN_FUNC iterator erase_first_unsorted(const T& value); // Same as erase, except it doesn't preserve order, but is faster because it simply copies the last item in the RandomAccessContainer over the erased position.
        
        DYN_FUNC iterator erase(const_iterator position);
        DYN_FUNC iterator erase(const_iterator first, const_iterator last);
        DYN_FUNC iterator erase_unsorted(const_iterator position);         // Same as erase, except it doesn't preserve order, but is faster because it simply copies the last item in the RandomAccessContainer over the erased position.
 
        DYN_FUNC void clear() noexcept; //clear will not change m_Begin and capacity, only change size and m_End
 
        private:
        size_type  m_size = 0;
        iterator    m_bufferEnd = nullptr;
        iterator    m_End = nullptr;
        iterator    m_Begin = nullptr;       //Logically, m_Begin is the iterator of the beginner of element, m_startLoc is the pointer to the container, though they will be equal in this implementation.
 
    }; // class RandomAccessContainer
 
}
 
#include "RandomAccessContainer.inl"
#endif // RANDOM_ACCESS_CONTAINER_H