StringIterator.h

#pragma once
 
#ifndef PL_INCLUDING_BASICS_H
#  error "Please don't include StringIterator.h directly, but instead include Foundation/Basics.h"
#endif
 
struct plStringIterator
{
  using iterator_category = std::bidirectional_iterator_tag;
  using value_type = plUInt32;
  using difference_type = std::ptrdiff_t;
  using pointer = const char*;
  using reference = plUInt32;
 
  PL_DECLARE_POD_TYPE();
 
  PL_ALWAYS_INLINE plStringIterator() = default; // [tested]
 
  PL_FORCE_INLINE explicit plStringIterator(const char* pStartPtr, const char* pEndPtr, const char* pCurPtr)
  {
    m_pStartPtr = pStartPtr;
    m_pEndPtr = pEndPtr;
    m_pCurPtr = pCurPtr;
  }
 
  PL_ALWAYS_INLINE bool IsValid() const { return m_pCurPtr != nullptr && m_pCurPtr != m_pEndPtr; } // [tested]
 
  PL_ALWAYS_INLINE plUInt32 GetCharacter() const { return IsValid() ? plUnicodeUtils::ConvertUtf8ToUtf32(m_pCurPtr) : plUInt32(0); } // [tested]
 
  PL_ALWAYS_INLINE plUInt32 operator*() const { return GetCharacter(); } // [tested]
 
  PL_ALWAYS_INLINE const char* GetData() const { return m_pCurPtr; } // [tested]
 
  PL_ALWAYS_INLINE bool operator==(const plStringIterator& it2) const { return (m_pCurPtr == it2.m_pCurPtr); } // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plStringIterator&);
 
  PL_ALWAYS_INLINE plUInt32 Advance()
  {
    const char* pPrevElement = m_pCurPtr;
 
    if (m_pCurPtr < m_pEndPtr)
    {
      plUnicodeUtils::MoveToNextUtf8(m_pCurPtr).AssertSuccess();
    }
 
    return static_cast<plUInt32>(m_pCurPtr - pPrevElement);
  }
 
  PL_ALWAYS_INLINE plStringIterator& operator++() // [tested]
  {
    if (m_pCurPtr < m_pEndPtr)
    {
      plUnicodeUtils::MoveToNextUtf8(m_pCurPtr).AssertSuccess();
    }
 
    return *this;
  }
 
  PL_ALWAYS_INLINE plStringIterator& operator--() // [tested]
  {
    if (m_pStartPtr < m_pCurPtr)
    {
      plUnicodeUtils::MoveToPriorUtf8(m_pCurPtr, m_pStartPtr).AssertSuccess();
    }
 
    return *this;
  }
 
  PL_ALWAYS_INLINE plStringIterator operator++(int) // [tested]
  {
    plStringIterator tmp = *this;
    ++(*this);
    return tmp;
  }
 
  PL_ALWAYS_INLINE plStringIterator operator--(int) // [tested]
  {
    plStringIterator tmp = *this;
    --(*this);
    return tmp;
  }
 
  PL_FORCE_INLINE void operator+=(difference_type d) // [tested]
  {
    while (d > 0)
    {
      ++(*this);
      --d;
    }
    while (d < 0)
    {
      --(*this);
      ++d;
    }
  }
 
  PL_FORCE_INLINE void operator-=(difference_type d) // [tested]
  {
    while (d > 0)
    {
      --(*this);
      --d;
    }
    while (d < 0)
    {
      ++(*this);
      ++d;
    }
  }
 
  PL_ALWAYS_INLINE plStringIterator operator+(difference_type d) const // [tested]
  {
    plStringIterator it = *this;
    it += d;
    return it;
  }
 
  PL_ALWAYS_INLINE plStringIterator operator-(difference_type d) const // [tested]
  {
    plStringIterator it = *this;
    it -= d;
    return it;
  }
 
  void SetCurrentPosition(const char* szCurPos)
  {
    PL_ASSERT_DEV((szCurPos >= m_pStartPtr) && (szCurPos <= m_pEndPtr), "New position must still be inside the iterator's range.");
 
    m_pCurPtr = szCurPos;
  }
 
private:
  const char* m_pStartPtr = nullptr;
  const char* m_pEndPtr = nullptr;
  const char* m_pCurPtr = nullptr;
};
 
 
struct plStringReverseIterator
{
  using iterator_category = std::bidirectional_iterator_tag;
  using value_type = plUInt32;
  using difference_type = std::ptrdiff_t;
  using pointer = const char*;
  using reference = plUInt32;
 
  PL_DECLARE_POD_TYPE();
 
  PL_ALWAYS_INLINE plStringReverseIterator() = default; // [tested]
 
  PL_FORCE_INLINE explicit plStringReverseIterator(const char* pStartPtr, const char* pEndPtr, const char* pCurPtr) // [tested]
  {
    m_pStartPtr = pStartPtr;
    m_pEndPtr = pEndPtr;
    m_pCurPtr = pCurPtr;
 
    if (m_pStartPtr >= m_pEndPtr)
    {
      m_pCurPtr = nullptr;
    }
    else if (m_pCurPtr == m_pEndPtr)
    {
      plUnicodeUtils::MoveToPriorUtf8(m_pCurPtr, m_pStartPtr).AssertSuccess();
    }
  }
 
  PL_ALWAYS_INLINE bool IsValid() const { return (m_pCurPtr != nullptr); } // [tested]
 
  PL_ALWAYS_INLINE plUInt32 GetCharacter() const { return IsValid() ? plUnicodeUtils::ConvertUtf8ToUtf32(m_pCurPtr) : plUInt32(0); } // [tested]
 
  PL_ALWAYS_INLINE plUInt32 operator*() const { return GetCharacter(); } // [tested]
 
  PL_ALWAYS_INLINE const char* GetData() const { return m_pCurPtr; } // [tested]
 
  PL_ALWAYS_INLINE bool operator==(const plStringReverseIterator& it2) const { return (m_pCurPtr == it2.m_pCurPtr); } // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plStringReverseIterator&);
 
  PL_FORCE_INLINE plStringReverseIterator& operator++() // [tested]
  {
    if (m_pCurPtr != nullptr && m_pStartPtr < m_pCurPtr)
      plUnicodeUtils::MoveToPriorUtf8(m_pCurPtr, m_pStartPtr).AssertSuccess();
    else
      m_pCurPtr = nullptr;
 
    return *this;
  }
 
  PL_FORCE_INLINE plStringReverseIterator& operator--() // [tested]
  {
    if (m_pCurPtr != nullptr)
    {
      const char* szOldPos = m_pCurPtr;
      plUnicodeUtils::MoveToNextUtf8(m_pCurPtr).AssertSuccess();
 
      if (m_pCurPtr == m_pEndPtr)
        m_pCurPtr = szOldPos;
    }
    else
    {
      // Set back to the first character.
      m_pCurPtr = m_pStartPtr;
    }
    return *this;
  }
 
  PL_ALWAYS_INLINE plStringReverseIterator operator++(int) // [tested]
  {
    plStringReverseIterator tmp = *this;
    ++(*this);
    return tmp;
  }
 
  PL_ALWAYS_INLINE plStringReverseIterator operator--(int) // [tested]
  {
    plStringReverseIterator tmp = *this;
    --(*this);
    return tmp;
  }
 
  PL_FORCE_INLINE void operator+=(difference_type d) // [tested]
  {
    while (d > 0)
    {
      ++(*this);
      --d;
    }
    while (d < 0)
    {
      --(*this);
      ++d;
    }
  }
 
  PL_FORCE_INLINE void operator-=(difference_type d) // [tested]
  {
    while (d > 0)
    {
      --(*this);
      --d;
    }
    while (d < 0)
    {
      ++(*this);
      ++d;
    }
  }
 
  PL_ALWAYS_INLINE plStringReverseIterator operator+(difference_type d) const // [tested]
  {
    plStringReverseIterator it = *this;
    it += d;
    return it;
  }
 
  PL_ALWAYS_INLINE plStringReverseIterator operator-(difference_type d) const // [tested]
  {
    plStringReverseIterator it = *this;
    it -= d;
    return it;
  }
 
  PL_FORCE_INLINE void SetCurrentPosition(const char* szCurPos)
  {
    PL_ASSERT_DEV((szCurPos == nullptr) || ((szCurPos >= m_pStartPtr) && (szCurPos < m_pEndPtr)), "New position must still be inside the iterator's range.");
 
    m_pCurPtr = szCurPos;
  }
 
private:
  const char* m_pStartPtr = nullptr;
  const char* m_pEndPtr = nullptr;
  const char* m_pCurPtr = nullptr;
};