TDeque.h

Go to the documentation of this file.

#pragma once
 
#include <climits>
#include <deque>
#include <iostream>
#include <iterator>
#include <sstream>
 
namespace sf
{
 
template<typename T>
class TDeque : public std::deque<T>
{
  public:
    typedef typename std::deque<T> base_type;
    typedef typename base_type::size_type size_type;
    typedef typename base_type::value_type value_type;
 
    static const size_t npos = static_cast<size_type>(-1);
 
    TDeque() = default;
 
    template<typename InputIterator>
    TDeque(InputIterator first, InputIterator last)
      : base_type(first, last)
    {}
 
    TDeque(std::initializer_list<value_type> list)
      : base_type(list)
    {}
 
    explicit TDeque(const base_type& sv)
      : base_type(sv)
    {}
 
    explicit TDeque(size_type sz)
      : base_type(sz)
    {}
 
    size_type add(const T&);
 
    size_type add(const TDeque<T>&);
 
    bool addAt(const 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();
    }
 
    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;
    }
 
#pragma clang diagnostic push
#pragma ide diagnostic ignored "HidingNonVirtualFunction"
 
    T& operator[](size_type i)
    {
      return base_type::at(i);
    }
 
    const T& operator[](size_type i) const
    {
      return base_type::at(i);
    }
 
#pragma clang diagnostic pop
 
    std::ostream& write(std::ostream& os, bool inc_hex) const;
};
 
template<typename T>
std::ostream& TDeque<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)
    {
      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, TDeque<T> const& v)
{
  return v.write(os, true);
}
 
template<typename T>
typename TDeque<T>::size_type TDeque<T>::add(const T& t)
{
  // Insert item at the end using iterator.
  return std::distance(base_type::begin(), base_type::insert(base_type::end(), t));
}
 
template<typename T>
typename TDeque<T>::size_type TDeque<T>::add(const TDeque<T>& tv)
{
  // Insert item at the end.
  return std::distance(base_type::begin(), base_type::insert(base_type::end(), tv.begin(), tv.end()));
}
 
template<typename T>
bool TDeque<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 TDeque<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 TDeque<T>::detach(const T& t)
{
  for (unsigned 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 TDeque<T>::size_type TDeque<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