ivectorpointer.h

Go to the documentation of this file.

 
/******************************************************************************
The MIT License(MIT)
 
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
 
Copyright(c) 2016 John Wellbelove
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
 
#ifndef ETL_IVECTOR_POINTER_INCLUDED
#define ETL_IVECTOR_POINTER_INCLUDED
 
#ifndef ETL_IN_VECTOR_H
  #error This header is a private element of etl::ivector
#endif
 
#include "pvoidvector.h"
 
namespace etl
{
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  class ivector<T*> : public pvoidvector
  {
  public:
 
    typedef T*                                                       value_type;
    typedef value_type&                                              reference;
    typedef const value_type&                                        const_reference;
    typedef value_type*                                              pointer;
    typedef const value_type*                                        const_pointer;
    typedef value_type*                                              iterator;
    typedef const value_type*                                        const_iterator;
    typedef ETL_OR_STD::reverse_iterator<iterator>                   reverse_iterator;
    typedef ETL_OR_STD::reverse_iterator<const_iterator>             const_reverse_iterator;
    typedef size_t                                                   size_type;
    typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
 
  protected:
 
    typedef value_type parameter_t;
 
  private:
 
    typedef pvoidvector base_t;
 
  public:
 
    //*********************************************************************
    //*********************************************************************
    iterator begin()
    {
      return iterator(base_t::begin());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_iterator begin() const
    {
      return const_iterator(base_t::begin());
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator end()
    {
      return iterator(base_t::end());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_iterator end() const
    {
      return const_iterator(base_t::end());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_iterator cbegin() const
    {
      return const_iterator(base_t::cbegin());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_iterator cend() const
    {
      return const_iterator(base_t::cend());
    }
 
    //*********************************************************************
    //*********************************************************************
    reverse_iterator rbegin()
    {
      return reverse_iterator(iterator(base_t::end()));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reverse_iterator rbegin() const
    {
      return const_reverse_iterator(const_iterator(base_t::end()));
    }
 
    //*********************************************************************
    //*********************************************************************
    reverse_iterator rend()
    {
      return reverse_iterator(iterator(base_t::begin()));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reverse_iterator rend() const
    {
      return const_reverse_iterator(const_iterator(base_t::begin()));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reverse_iterator crbegin() const
    {
      return const_reverse_iterator(const_iterator(base_t::cend()));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reverse_iterator crend() const
    {
      return const_reverse_iterator(const_iterator(base_t::cbegin()));
    }
 
    //*********************************************************************
    //*********************************************************************
    void resize(size_t new_size)
    {
      base_t::resize(new_size);
    }
 
    //*********************************************************************
    //*********************************************************************
    void resize(size_t new_size, value_type value)
    {
      base_t::resize(new_size, value);
    }
 
    //*********************************************************************
    //*********************************************************************
    void uninitialized_resize(size_t new_size)
    {
      base_t::uninitialized_resize(new_size);
    }
 
    //*********************************************************************
    //*********************************************************************
    reference operator[](size_t i)
    {
      return reference(base_t::operator[](i));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reference operator[](size_t i) const
    {
      return const_reference(base_t::operator[](i));
    }
 
    //*********************************************************************
    //*********************************************************************
    reference at(size_t i)
    {
      return reference(base_t::at(i));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reference at(size_t i) const
    {
      return const_reference(base_t::at(i));
    }
 
    //*********************************************************************
    //*********************************************************************
    reference front()
    {
      return reference(base_t::front());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reference front() const
    {
      return const_reference(base_t::front());
    }
 
    //*********************************************************************
    //*********************************************************************
    reference back()
    {
      return reference(base_t::back());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reference back() const
    {
      return const_reference(base_t::back());
    }
 
    //*********************************************************************
    //*********************************************************************
    pointer data()
    {
      return pointer(base_t::data());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_pointer data() const
    {
      return const_pointer(base_t::data());
    }
 
    //*********************************************************************
    //*********************************************************************
    template <typename TIterator>
    void assign(TIterator first, TIterator last)
    {
      base_t::assign(first, last);
    }
 
    //*********************************************************************
    //*********************************************************************
    void assign(size_t n, parameter_t value)
    {
      base_t::assign(n, value);
    }
 
    //*************************************************************************
    //*************************************************************************
    void clear()
    {
      base_t::clear();
    }
 
    //*********************************************************************
    //*********************************************************************
    void push_back(parameter_t value)
    {
      base_t::push_back(value);
    }
 
    //*********************************************************************
    //*********************************************************************
    reference emplace_back()
    {
      base_t::emplace_back(ETL_NULLPTR);
 
      return back();
    }
 
    //*********************************************************************
    //*********************************************************************
    reference emplace_back(parameter_t value)
    {
      base_t::emplace_back(value);
 
      return back();
    }
 
    //*************************************************************************
    //*************************************************************************
    void pop_back()
    {
      base_t::pop_back();
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator insert(const_iterator position, parameter_t value)
    {
      return iterator(base_t::insert(base_t::iterator(position), value));
    }
 
    //*************************************************************************
    //*************************************************************************
    iterator emplace(const_iterator position)
    {
      return iterator(base_t::emplace(base_t::iterator(position), ETL_NULLPTR));
    }
 
    //*************************************************************************
    //*************************************************************************
    iterator emplace(const_iterator position, parameter_t value)
    {
      return iterator(base_t::emplace(base_t::iterator(position), value));
    }
 
    //*********************************************************************
    //*********************************************************************
    void insert(const_iterator position, size_t n, parameter_t value)
    {
      base_t::insert(base_t::iterator(position), n, value);
    }
 
    //*********************************************************************
    //*********************************************************************
    template <class TIterator>
    void insert(const_iterator position, TIterator first, TIterator last)
    {
      base_t::insert(base_t::iterator(position), first, last);
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator erase(iterator i_element)
    {
      return iterator(base_t::erase(base_t::iterator(i_element)));
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator erase(const_iterator i_element)
    {
      return iterator(base_t::erase(base_t::const_iterator(i_element)));
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator erase(const_iterator first, const_iterator last)
    {
      return iterator(base_t::erase(base_t::const_iterator(first), base_t::const_iterator(last)));
    }
 
    //*********************************************************************
    //*********************************************************************
    void swap(ivector<T*>& other)
    {
      if (this == &other)
      {
        return;
      }
 
      ETL_ASSERT_OR_RETURN(this->max_size() >= other.size() && other.max_size() >= this->size(), ETL_ERROR(vector_full));
 
      ivector<T*>& smaller = other.size() > this->size() ? *this : other;
      ivector<T*>& larger  = other.size() > this->size() ? other : *this;
 
      etl::swap_ranges(smaller.begin(), smaller.end(), larger.begin());
 
      typename ivector<T*>::iterator larger_itr = etl::next(larger.begin(), static_cast<ptrdiff_t>(smaller.size()));
 
      etl::move(larger_itr, larger.end(), etl::back_inserter(smaller));
 
      larger.erase(larger_itr, larger.end());
    }
 
    //*************************************************************************
    //*************************************************************************
    ivector& operator=(const ivector& rhs)
    {
      base_t::operator=(rhs);
 
      return *this;
    }
 
#if ETL_USING_CPP11
    //*************************************************************************
    //*************************************************************************
    ivector& operator=(ivector&& rhs)
    {
      (void)base_t::operator=(etl::move(rhs));
 
      return *this;
    }
#endif
 
#ifdef ETL_IVECTOR_REPAIR_ENABLE
    //*************************************************************************
    //*************************************************************************
    virtual void repair() = 0;
#endif
 
  protected:
 
    //*********************************************************************
    //*********************************************************************
    ivector(T** p_buffer_, size_t MAX_SIZE_)
      : pvoidvector(reinterpret_cast<void**>(p_buffer_), MAX_SIZE_)
    {
    }
  };
 
  template <typename T>
  class ivector<const T*> : public pvoidvector
  {
  public:
 
    typedef const T*                                                 value_type;
    typedef value_type&                                              reference;
    typedef const value_type&                                        const_reference;
    typedef value_type*                                              pointer;
    typedef const value_type*                                        const_pointer;
    typedef value_type*                                              iterator;
    typedef const value_type*                                        const_iterator;
    typedef ETL_OR_STD::reverse_iterator<iterator>                   reverse_iterator;
    typedef ETL_OR_STD::reverse_iterator<const_iterator>             const_reverse_iterator;
    typedef size_t                                                   size_type;
    typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
 
  protected:
 
    typedef value_type parameter_t;
 
  private:
 
    typedef pvoidvector base_t;
 
  public:
 
    //*********************************************************************
    //*********************************************************************
    iterator begin()
    {
      return iterator(base_t::begin());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_iterator begin() const
    {
      return const_iterator(base_t::begin());
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator end()
    {
      return iterator(base_t::end());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_iterator end() const
    {
      return const_iterator(base_t::end());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_iterator cbegin() const
    {
      return const_iterator(base_t::cbegin());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_iterator cend() const
    {
      return const_iterator(base_t::cend());
    }
 
    //*********************************************************************
    //*********************************************************************
    reverse_iterator rbegin()
    {
      return reverse_iterator(iterator(base_t::end()));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reverse_iterator rbegin() const
    {
      return const_reverse_iterator(const_iterator(base_t::end()));
    }
 
    //*********************************************************************
    //*********************************************************************
    reverse_iterator rend()
    {
      return reverse_iterator(iterator(base_t::begin()));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reverse_iterator rend() const
    {
      return const_reverse_iterator(const_iterator(base_t::begin()));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reverse_iterator crbegin() const
    {
      return const_reverse_iterator(const_iterator(base_t::cend()));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reverse_iterator crend() const
    {
      return const_reverse_iterator(const_iterator(base_t::cbegin()));
    }
 
    //*********************************************************************
    //*********************************************************************
    void resize(size_t new_size)
    {
      base_t::resize(new_size);
    }
 
    //*********************************************************************
    //*********************************************************************
    void resize(size_t new_size, value_type value)
    {
      base_t::resize(new_size, const_cast<T*>(value));
    }
 
    //*********************************************************************
    //*********************************************************************
    void uninitialized_resize(size_t new_size)
    {
      base_t::uninitialized_resize(new_size);
    }
 
    //*********************************************************************
    //*********************************************************************
    reference operator[](size_t i)
    {
      return reference(base_t::operator[](i));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reference operator[](size_t i) const
    {
      return const_reference(base_t::operator[](i));
    }
 
    //*********************************************************************
    //*********************************************************************
    reference at(size_t i)
    {
      return reference(base_t::at(i));
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reference at(size_t i) const
    {
      return const_reference(base_t::at(i));
    }
 
    //*********************************************************************
    //*********************************************************************
    reference front()
    {
      return reference(base_t::front());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reference front() const
    {
      return const_reference(base_t::front());
    }
 
    //*********************************************************************
    //*********************************************************************
    reference back()
    {
      return reference(base_t::back());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_reference back() const
    {
      return const_reference(base_t::back());
    }
 
    //*********************************************************************
    //*********************************************************************
    pointer data()
    {
      return pointer(base_t::data());
    }
 
    //*********************************************************************
    //*********************************************************************
    const_pointer data() const
    {
      return const_pointer(base_t::data());
    }
 
    //*********************************************************************
    //*********************************************************************
    template <typename TIterator>
    void assign(TIterator first, TIterator last)
    {
      base_t::assign(first, last);
    }
 
    //*********************************************************************
    //*********************************************************************
    void assign(size_t n, parameter_t value)
    {
      base_t::assign(n, const_cast<T*>(value));
    }
 
    //*************************************************************************
    //*************************************************************************
    void clear()
    {
      base_t::clear();
    }
 
    //*********************************************************************
    //*********************************************************************
    void push_back(parameter_t value)
    {
      base_t::push_back(const_cast<T*>(value));
    }
 
    //*************************************************************************
    //*************************************************************************
    void pop_back()
    {
      base_t::pop_back();
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator insert(const_iterator position, parameter_t value)
    {
      return iterator(base_t::insert(base_t::iterator(position), const_cast<T*>(value)));
    }
 
    //*********************************************************************
    //*********************************************************************
    void insert(const_iterator position, size_t n, parameter_t value)
    {
      base_t::insert(base_t::iterator(position), n, const_cast<T*>(value));
    }
 
    //*********************************************************************
    //*********************************************************************
    template <class TIterator>
    void insert(const_iterator position, TIterator first, TIterator last)
    {
      base_t::insert(base_t::iterator(position), first, last);
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator erase(iterator i_element)
    {
      return iterator(base_t::erase(base_t::iterator(i_element)));
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator erase(const_iterator i_element)
    {
      return iterator(base_t::erase(base_t::iterator(i_element)));
    }
 
    //*********************************************************************
    //*********************************************************************
    iterator erase(const_iterator first, const_iterator last)
    {
      return iterator(base_t::erase(base_t::iterator(first), base_t::iterator(last)));
    }
 
    //*********************************************************************
    //*********************************************************************
    void swap(ivector<const T*>& other)
    {
      if (this == &other)
      {
        return;
      }
 
      ETL_ASSERT_OR_RETURN(this->max_size() >= other.size() && other.max_size() >= this->size(), ETL_ERROR(vector_full));
 
      ivector<const T*>& smaller = other.size() > this->size() ? *this : other;
      ivector<const T*>& larger  = other.size() > this->size() ? other : *this;
 
      etl::swap_ranges(smaller.begin(), smaller.end(), larger.begin());
 
      typename ivector<const T*>::iterator larger_itr = etl::next(larger.begin(), static_cast<ptrdiff_t>(smaller.size()));
 
      etl::move(larger_itr, larger.end(), etl::back_inserter(smaller));
 
      larger.erase(larger_itr, larger.end());
    }
 
    //*************************************************************************
    //*************************************************************************
    ivector& operator=(const ivector& rhs)
    {
      base_t::operator=(rhs);
 
      return *this;
    }
 
#if ETL_USING_CPP11
    //*************************************************************************
    //*************************************************************************
    ivector& operator=(ivector&& rhs)
    {
      (void)base_t::operator=(etl::move(rhs));
 
      return *this;
    }
#endif
 
#ifdef ETL_IVECTOR_REPAIR_ENABLE
    //*************************************************************************
    //*************************************************************************
    virtual void repair() = 0;
#endif
 
  protected:
 
    //*********************************************************************
    //*********************************************************************
    ivector(const T** p_buffer_, size_t MAX_SIZE_)
      : pvoidvector(reinterpret_cast<void**>(const_cast<T**>(p_buffer_)), MAX_SIZE_)
    {
    }
  };
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  bool operator==(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
  {
    return pvoidvector_equal(lhs, rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  bool operator!=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
  {
    return pvoidvector_not_equal(lhs, rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  bool operator<(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
  {
    return pvoidvector_less_than(lhs, rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  bool operator>(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
  {
    return pvoidvector_greater_than(lhs, rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  bool operator<=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
  {
    return pvoidvector_less_than_equal(lhs, rhs);
  }
 
  //***************************************************************************
  //***************************************************************************
  template <typename T>
  bool operator>=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
  {
    return pvoidvector_greater_than_equal(lhs, rhs);
  }
 
  //***************************************************************************
  // Helper functions
  //***************************************************************************
  inline bool pvoidvector_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
  {
    return operator==(lhs, rhs);
  }
 
  inline bool pvoidvector_not_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
  {
    return operator!=(lhs, rhs);
  }
 
  inline bool pvoidvector_less_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
  {
    return operator<(lhs, rhs);
  }
 
  inline bool pvoidvector_greater_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
  {
    return operator>(lhs, rhs);
  }
 
  inline bool pvoidvector_less_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
  {
    return operator<=(lhs, rhs);
  }
 
  inline bool pvoidvector_greater_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
  {
    return operator>=(lhs, rhs);
  }
} // namespace etl
 
#endif