TVector.h

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <cinttypes>
#include <iterator>
#include <ostream>
#include <vector>
 
namespace sf
{
 
template<typename T>
class TIterator;
 
template<typename T>
class TVector : public std::vector<T>
{
  public:
    typedef std::vector<T> base_type;
    typedef typename base_type::size_type size_type;
    typedef typename base_type::value_type value_type;
    typedef TIterator<value_type> iter_type;
    typedef const iter_type const_iter_type;
 
    static const size_t npos = static_cast<size_type>(-1);
 
    TVector() = default;
 
    TVector(const TVector& v);
 
    TVector(TVector&&) noexcept = default;
 
    TVector& operator=(const TVector& v) noexcept;
 
    TVector& operator=(TVector&& v) noexcept;
 
    template<typename InputIterator>
    TVector(InputIterator first, InputIterator last);
 
    TVector(std::initializer_list<value_type> list);
 
    explicit TVector(const base_type& sv);
 
    explicit TVector(size_type sz);
 
    size_type add(const T& t);
 
    size_type add(T&& t);
 
    TVector& append(const T& t);
 
    TVector& append(T&& t);
 
    TVector& prepend(const T& t);
 
    TVector& prepend(T&& t);
 
    size_type add(const TVector&);
 
    bool addAt(const T& t, size_type index);
 
    bool addAt(T&& t, size_type index);
 
    bool detach(const T& t);
 
    bool detachAt(size_type index);
 
    [[nodiscard]] bool isEmpty() const;
 
    void flush();
 
    void flush(size_type stop, size_type start = 0);
 
    size_type find(const T&) const;
 
    [[nodiscard]] size_type count() const;
 
    T& first();
 
    const T& first() const noexcept;
 
    T& last();
 
    const T& last() const noexcept;
 
    bool startsWith(T t) const;
 
    bool endsWith(T t) const;
 
    T& get(size_type i);
 
    const T& get(size_type i) const;
 
    base_type getBase();
 
    base_type getBase() const;
 
    T& operator[](size_type i);
 
    const T& operator[](size_type i) const;
 
    std::ostream& write(std::ostream& os, bool inc_hex) const;
};
 
template<typename T>
T& TVector<T>::last()
{
  assert(!base_type::empty());
  return *(base_type::end() - 1);
}
 
template<typename T>
const T& TVector<T>::last() const noexcept
{
  assert(!base_type::empty());
  return *(base_type::end() - 1);
}
 
template<typename T>
bool TVector<T>::startsWith(T t) const
{
  return !base_type::empty() && first() == t;
}
 
template<typename T>
bool TVector<T>::endsWith(T t) const
{
  return !base_type::empty() && last() == t;
}
 
template<typename T>
T& TVector<T>::get(size_type i)
{
  return base_type::at(i);
}
 
template<typename T>
const T& TVector<T>::get(size_type i) const
{
  return base_type::at(i);
}
 
template<typename T>
typename TVector<T>::base_type TVector<T>::getBase()
{
  return this;
}
 
template<typename T>
typename TVector<T>::base_type TVector<T>::getBase() const
{
  return this;
}
 
template<typename T>
T& TVector<T>::operator[](size_type i)
{
  return base_type::at(i);
}
 
template<typename T>
const T& TVector<T>::operator[](size_type i) const
{
  return base_type::at(i);
}
 
template<typename T>
std::ostream& TVector<T>::write(std::ostream& os, bool inc_hex) const
{
  os << '{';
  for (const auto& x: *this)
  {
    os << std::dec << x;
    if (inc_hex && std::is_integral_v<T>)
    {
      uint64_t _x{0};
      for (int i = 0; i < sizeof(T); i++)
      {
        // ReSharper disable file CppCStyleCast
        ((uint8_t*) &_x)[i] = ((uint8_t*) &x)[i];
      }
      os << " (" << std::hex << "0x" << _x << ')';
    }
    // Check if this is the last entry in the list using pointer comparison instead of value.
    if (&(*(base_type::end() - 1)) != &x)
    {
      os << ", ";
    }
  }
  return os << std::dec << '}';
}
 
template<typename T>
std::ostream& operator<<(std::ostream& os, TVector<T> const& v)
{
  return v.write(os, true);
}
 
template<typename T>
class TIterator
{
  public:
    typedef std::vector<T> base_t;
 
    explicit TIterator(const base_t& v);
 
    TIterator(const base_t& v, size_t start, size_t stop);
 
    operator int() const;
 
    const T& current() const;
 
    T& current();
 
    const T& operator++(int);
 
    const T& operator++();
 
    void restart();
 
    void restart(unsigned start, unsigned stop)
    {
      _cur = _lower = start;
      _upper = stop;
    }
 
  private:
    base_t* _vector;
    unsigned _cur{};
    unsigned _lower{};
    unsigned _upper{};
};
 
template<typename T>
TVector<T>::TVector(const TVector& v)
  : base_type(v)
{}
 
template<typename T>
TVector<T>& TVector<T>::operator=(const TVector& v) noexcept
{
  *static_cast<base_type*>(this) = static_cast<base_type>(v);
  return *this;
}
 
template<typename T>
TVector<T>& TVector<T>::operator=(TVector&& v) noexcept
{
  *static_cast<base_type*>(this) = static_cast<base_type>(v);
  return *this;
}
 
template<typename T>
template<typename InputIterator>
TVector<T>::TVector(InputIterator first, InputIterator last)
  : base_type(first, last)
{}
 
template<typename T>
TVector<T>::TVector(std::initializer_list<value_type> list)
  : base_type(list)
{}
 
template<typename T>
TVector<T>::TVector(const base_type& sv)
  : base_type(sv)
{}
 
template<typename T>
TVector<T>::TVector(size_type sz)
  : base_type(sz)
{}
 
template<typename T>
typename TVector<T>::size_type TVector<T>::add(const T& t)
{
  // Insert item at the end.
  base_type::push_back(t);
  // Index it the size minus one.
  return base_type::size() - 1;
}
 
template<typename T>
typename TVector<T>::size_type TVector<T>::add(T&& t)
{
  // Insert item at the end.
  base_type::push_back(t);
  // Index it the size minus one.
  return base_type::size() - 1;
}
 
template<typename T>
TVector<T>& TVector<T>::append(const T& t)
{
  // Insert item at the end.
  base_type::push_back(t);
  return *this;
}
 
template<typename T>
TVector<T>& TVector<T>::append(T&& t)
{
  // Insert item at the end.
  base_type::push_back(std::move(t));
  return *this;
}
 
template<typename T>
TVector<T>& TVector<T>::prepend(const T& t)
{
  base_type::insert(base_type::begin(), t);
  return *this;
}
 
template<typename T>
TVector<T>& TVector<T>::prepend(T&& t)
{
  base_type::insert(base_type::begin(), std::move(t));
  return *this;
}
 
template<typename T>
typename TVector<T>::size_type TVector<T>::add(const TVector& tv)
{
  // The insertion index is the current size.
  auto index = base_type::size();
  // Insert items at the end.
  base_type::insert(base_type::end(), tv.begin(), tv.end());
  return index;
}
 
template<typename T>
bool TVector<T>::addAt(const T& t, size_type index)
{
  // Check if index is in range.
  if (index > base_type::size())
  {
    return false;
  }
  if (index == base_type::size())
  {
    base_type::insert(base_type::end(), t);
  }
  else
  {
    base_type::insert(base_type::begin() + index, t);
  }
  return true;
}
 
template<typename T>
bool TVector<T>::addAt(T&& t, size_type index)
{
  // Check if index is in range.
  if (index > base_type::size())
  {
    return false;
  }
  if (index == base_type::size())
  {
    base_type::insert(base_type::end(), t);
  }
  else
  {
    base_type::insert(base_type::begin() + index, t);
  }
  return true;
}
 
template<typename T>
bool TVector<T>::detachAt(size_type index)
{
  // Check if index is in range.
  if (index >= base_type::size())
  {
    return false;
  }
  base_type::erase(base_type::begin() + index, base_type::begin() + index + 1);
  return true;
}
 
template<typename T>
bool TVector<T>::isEmpty() const
{
  return base_type::empty();
}
 
template<typename T>
void TVector<T>::flush()
{
  base_type::erase(base_type::begin(), base_type::end());
}
 
template<typename T>
bool TVector<T>::detach(const T& t)
{
  for (size_type i = 0; i < base_type::size(); ++i)
  {
    if (base_type::at(i) == t)
    {
      base_type::erase(base_type::begin() + i, base_type::begin() + i + 1);
      return true;
    }
  }
  return false;
}
 
template<typename T>
void TVector<T>::flush(size_type stop, size_type start)
{
  base_type::erase(base_type::begin() + start, base_type::end() + ((stop >= base_type::size()) ? (base_type::size() - 1) : stop));
}
 
template<typename T>
typename TVector<T>::size_type TVector<T>::find(const T& t) const
{
  for (size_type i = 0; i < base_type::size(); ++i)
  {
    if (base_type::at(i) == t)
    {
      return i;
    }
  }
  return npos;
}
 
template<typename T>
typename TVector<T>::size_type TVector<T>::count() const
{
  return base_type::size();
}
 
template<typename T>
T& TVector<T>::first()
{
  assert(!base_type::empty());
  return *base_type::begin();
}
 
template<typename T>
const T& TVector<T>::first() const noexcept
{
  static_assert(!base_type::empty());
  return *base_type::begin();
}
 
template<typename T>
TIterator<T>::TIterator(const base_t& v)
{
  _vector = const_cast<base_t*>(&v);
  restart(0, _vector->size());
}
 
template<typename T>
TIterator<T>::TIterator(const base_t& v, size_t start, size_t stop)
{
  _vector = &v;
  restart(start, stop);
}
 
template<typename T>
TIterator<T>::operator int() const
{
  return _cur < _upper;
}
 
template<typename T>
const T& TIterator<T>::current() const
{
  return (*_vector)[_cur];
}
 
template<typename T>
T& TIterator<T>::current()
{
  return (*_vector)[_cur];
}
 
template<typename T>
const T& TIterator<T>::operator++(int)
{
  const T& temp = current();
  _cur++;
  return temp;
}
 
template<typename T>
const T& TIterator<T>::operator++()
{
  _cur++;
  return current();
}
 
template<typename T>
void TIterator<T>::restart()
{
  restart(_lower, _upper);
}
 
}// namespace sf