TVector.h

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <cinttypes>
#include <climits>
#include <iostream>
#include <iterator>
#include <limits>
#include <sstream>
#include <vector>
 
namespace sf
{
 
template<typename T>
class TIterator;
 
template<typename T>
class TVector : public std::vector<T>
{
  public:
    typedef typename 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)
      : base_type(v)
    {}
 
    TVector(TVector&&) noexcept = default;
 
    TVector& operator=(const TVector& v) noexcept
    {
      *((base_type*) this) = (base_type) v;
      return *this;
    }
 
    TVector& operator=(TVector&& v) noexcept
    {
      *((base_type*) this) = (base_type) v;
      return *this;
    }
 
    template<typename InputIterator>
    TVector(InputIterator first, InputIterator last)
      : base_type(first, last)
    {}
 
    TVector(std::initializer_list<value_type> list)
      : base_type(list)
    {}
 
    explicit TVector(const base_type& sv)
      : base_type(sv)
    {}
 
    explicit TVector(size_type sz)
      : base_type(sz)
    {}
 
    size_type add(const T& t);
 
    size_type add(T&& t);
 
    TVector<T>& append(const T& t);
 
    TVector<T>& append(T&& t);
 
    size_type add(const TVector<T>&);
 
    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
    {
      return base_type::empty();
    }
 
    void flush()
    {
      base_type::erase(base_type::begin(), base_type::end());
    }
 
    void flush(size_type stop, size_type start = 0)
    {
      base_type::erase(base_type::begin() + start, base_type::end() + ((stop >= base_type::size()) ? (base_type::size() - 1) : stop));
    }
 
    size_type find(const T&) const;
 
    [[nodiscard]] size_type count() const
    {
      return base_type::size();
    }
 
    inline T& first()
    {
      assert(!base_type::empty());
      return *base_type::begin();
    }
 
    inline const T& first() const noexcept
    {
      static_assert(!base_type::empty());
      return *base_type::begin();
    }
 
    inline T& last()
    {
      assert(!base_type::empty());
      return *(base_type::end() - 1);
    }
 
    inline const T& last() const noexcept
    {
      assert(!base_type::empty());
      return *(base_type::end() - 1);
    }
 
    inline bool startsWith(T t) const
    {
      return !base_type::empty() && first() == t;
    }
 
    inline bool endsWith(T t) const
    {
      return !base_type::empty() && last() == t;
    }
 
    inline T& get(size_type i)
    {
      return base_type::at(i);
    }
 
    const T& get(size_type i) const
    {
      return base_type::at(i);
    }
 
    base_type getBase()
    {
      return this;
    }
 
    base_type getBase() const
    {
      return this;
    }
 
    T& operator[](size_type i)
    {
      return base_type::at(i);
    }
 
    const T& operator[](size_type i) const
    {
      return base_type::at(i);
    }
 
    std::ostream& write(std::ostream& os, bool inc_hex) const;
};
 
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<T>::value)
    {
      uint64_t _x{0};
      for (int i = 0; i < sizeof(T); i++)
      {
        ((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)
    {
      _vector = const_cast<base_t*>(&v);
      restart(0, _vector->size());
    }
 
    TIterator(const base_t& v, size_t start, size_t stop)
    {
      _vector = &v;
      restart(start, stop);
    }
 
    operator int() const
    {
      return _cur < _upper;
    }
 
    const T& current() const
    {
      return (*_vector)[_cur];
    }
 
    T& current()
    {
      return (*_vector)[_cur];
    }
 
    const T& operator++(int)
    {
      const T& temp = current();
      _cur++;
      return temp;
    }
 
    const T& operator++()
    {
      _cur++;
      return current();
    }
 
    void restart()
    {
      restart(_lower, _upper);
    }
 
    void restart(unsigned start, unsigned stop)
    {
      _cur = _lower = start;
      _upper = stop;
    }
 
  private:
    base_t* _vector;
    unsigned _cur{};
    unsigned _lower{};
    unsigned _upper{};
};
 
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>
typename TVector<T>::size_type TVector<T>::add(const TVector<T>& 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>::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>
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;
}
 
}// namespace sf