Bananymous
/
banan-os
1
1
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BAN: Iterators are now single general type with CONST template 

This allows us to use the same base class for iterator and
const_iterator which were practically the same code.
This commit is contained in:
Bananymous 2023-07-12 13:35:21 +03:00
parent 5df48804e1
commit 16acd50559
1 changed files with 71 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

283
BAN/include/BAN/Iterators.h
View File

@ -5,91 +5,13 @@
namespace BAN
{
template<typename T, typename Container>
class IteratorSimple
template<typename T, typename Container, bool CONST>
class IteratorSimpleGeneral
{
public:
IteratorSimple() = default;
const T& operator*() const
{
ASSERT(m_pointer);
return *m_pointer;
}
T& operator*()
{
ASSERT(m_pointer);
return *m_pointer;
}
const T* operator->() const
{
ASSERT(m_pointer);
return m_pointer;
}
T* operator->()
{
ASSERT(m_pointer);
return m_pointer;
}
IteratorSimple& operator++()
{
ASSERT(m_pointer);
++m_pointer;
return *this;
}
IteratorSimple operator++(int)
{
auto temp = *this;
++(*this);
return temp;
}
IteratorSimple& operator--()
{
ASSERT(m_pointer);
return --m_pointer;
}
IteratorSimple operator--(int)
{
auto temp = *this;
--(*this);
return temp;
}
bool operator==(const IteratorSimple& other) const
{
return m_pointer == other.m_pointer;
}
bool operator!=(const IteratorSimple& other) const
{
return !(*this == other);
}
operator bool() const
{
return m_pointer;
}
private:
IteratorSimple(T* pointer)
: m_pointer(pointer)
{
}
private:
T* m_pointer = nullptr;
friend Container;
};
template<typename T, typename Container>
class ConstIteratorSimple
{
public:
ConstIteratorSimple() = default;
ConstIteratorSimple(IteratorSimple<T, Container> other)
IteratorSimpleGeneral() = default;
template<bool CONST2, typename = enable_if_t<CONST2 == CONST || CONST>>
IteratorSimpleGeneral(const IteratorSimpleGeneral<T, Container, CONST2>& other)
: m_pointer(other.m_pointer)
{
}
@ -99,183 +21,91 @@ namespace BAN
ASSERT(m_pointer);
return *m_pointer;
}
template<bool CONST2 = CONST>
enable_if_t<!CONST2, T&> operator*()
{
ASSERT(m_pointer);
return *m_pointer;
}
const T* operator->() const
{
ASSERT(m_pointer);
return m_pointer;
}
template<bool CONST2 = CONST>
enable_if_t<!CONST2, T*> operator->()
{
ASSERT(m_pointer);
return m_pointer;
}
ConstIteratorSimple& operator++()
IteratorSimpleGeneral& operator++()
{
ASSERT(m_pointer);
++m_pointer;
return *this;
}
ConstIteratorSimple operator++(int)
IteratorSimpleGeneral operator++(int)
{
auto temp = *this;
++(*this);
return temp;
}
ConstIteratorSimple& operator--()
IteratorSimpleGeneral& operator--()
{
ASSERT(m_pointer);
return --m_pointer;
}
ConstIteratorSimple operator--(int)
IteratorSimpleGeneral operator--(int)
{
auto temp = *this;
--(*this);
return temp;
}
bool operator==(const ConstIteratorSimple& other) const
bool operator==(const IteratorSimpleGeneral& other) const
{
return m_pointer == other.m_pointer;
}
bool operator!=(const ConstIteratorSimple& other) const
bool operator!=(const IteratorSimpleGeneral& other) const
{
return !(*this == other);
}
operator bool() const
{
return !!m_pointer;
return m_pointer;
}
private:
ConstIteratorSimple(const T* pointer)
IteratorSimpleGeneral(maybe_const_t<CONST, T>* pointer)
: m_pointer(pointer)
{
}
private:
const T* m_pointer = nullptr;
maybe_const_t<CONST, T>* m_pointer = nullptr;
friend IteratorSimpleGeneral<T, Container, !CONST>;
friend Container;
};
template<typename T, template <typename> typename OuterContainer, template <typename> typename InnerContainer, typename Container>
class IteratorDouble
template<typename T, template<typename> typename OuterContainer, template<typename> typename InnerContainer, typename Container, bool CONST>
class IteratorDoubleGeneral
{
public:
using Inner = InnerContainer<T>;
using Outer = OuterContainer<Inner>;
public:
IteratorDouble() = default;
const T& operator*() const
{
ASSERT(*this);
ASSERT(m_outer_current != m_outer_end);
ASSERT(m_inner_current);
return m_inner_current.operator*();
}
T& operator*()
{
ASSERT(*this);
ASSERT(m_outer_current != m_outer_end);
ASSERT(m_inner_current);
return m_inner_current.operator*();
}
const T* operator->() const
{
ASSERT(*this);
ASSERT(m_outer_current != m_outer_end);
ASSERT(m_inner_current);
return m_inner_current.operator->();
}
T* operator->()
{
ASSERT(*this);
ASSERT(m_outer_current != m_outer_end);
ASSERT(m_inner_current);
return m_inner_current.operator->();
}
IteratorDouble& operator++()
{
ASSERT(*this);
ASSERT(m_outer_current != m_outer_end);
ASSERT(m_inner_current);
m_inner_current++;
find_valid_or_end();
return *this;
}
IteratorDouble operator++(int)
{
auto temp = *this;
++(*this);
return temp;
}
bool operator==(const IteratorDouble& other) const
{
if (!*this || !other)
return false;
if (m_outer_end != other.m_outer_end)
return false;
if (m_outer_current != other.m_outer_current)
return false;
if (m_outer_current == m_outer_end)
return true;
return m_inner_current == other.m_inner_current;
}
bool operator!=(const IteratorDouble& other) const
{
return !(*this == other);
}
operator bool() const
{
return m_outer_end && m_outer_current;
}
private:
IteratorDouble(Outer::iterator outer_end, Outer::iterator outer_current)
: m_outer_end(outer_end)
, m_outer_current(outer_current)
{
if (outer_current != outer_end)
{
m_inner_current = m_outer_current->begin();
find_valid_or_end();
}
}
void find_valid_or_end()
{
while (m_inner_current == m_outer_current->end())
{
m_outer_current++;
if (m_outer_current == m_outer_end)
break;
m_inner_current = m_outer_current->begin();
}
}
private:
Outer::iterator m_outer_end;
Outer::iterator m_outer_current;
Inner::iterator m_inner_current;
friend Container;
};
template<typename T, template <typename> typename OuterContainer, template <typename> typename InnerContainer, typename Container>
class ConstIteratorDouble
{
public:
using Inner = InnerContainer<T>;
using Outer = OuterContainer<Inner>;
using InnerIterator = either_or_t<CONST, typename Inner::const_iterator, typename Inner::iterator>;
using OuterIterator = either_or_t<CONST, typename Outer::const_iterator, typename Outer::iterator>;
public:
ConstIteratorDouble() = default;
ConstIteratorDouble(const IteratorDouble<T, OuterContainer, InnerContainer, Container>& other)
IteratorDoubleGeneral() = default;
template<bool CONST2, typename = enable_if_t<CONST2 == CONST || CONST>>
IteratorDoubleGeneral(const IteratorDoubleGeneral<T, OuterContainer, InnerContainer, Container, CONST2>& other)
: m_outer_end(other.m_outer_end)
, m_outer_current(other.m_outer_current)
, m_inner_current(other.m_inner_current)
@ -289,6 +119,14 @@ namespace BAN
ASSERT(m_inner_current);
return m_inner_current.operator*();
}
template<bool CONST2 = CONST>
enable_if_t<!CONST2, T&> operator*()
{
ASSERT(*this);
ASSERT(m_outer_current != m_outer_end);
ASSERT(m_inner_current);
return m_inner_current.operator*();
}
const T* operator->() const
{
@ -297,8 +135,16 @@ namespace BAN
ASSERT(m_inner_current);
return m_inner_current.operator->();
}
template<bool CONST2 = CONST>
enable_if_t<!CONST2, T*> operator->()
{
ASSERT(*this);
ASSERT(m_outer_current != m_outer_end);
ASSERT(m_inner_current);
return m_inner_current.operator->();
}
ConstIteratorDouble& operator++()
IteratorDoubleGeneral& operator++()
{
ASSERT(*this);
ASSERT(m_outer_current != m_outer_end);
@ -307,14 +153,14 @@ namespace BAN
find_valid_or_end();
return *this;
}
ConstIteratorDouble operator++(int)
IteratorDoubleGeneral operator++(int)
{
auto temp = *this;
++(*this);
return temp;
}
bool operator==(const ConstIteratorDouble& other) const
bool operator==(const IteratorDoubleGeneral& other) const
{
if (!*this || !other)
return false;
@ -326,7 +172,7 @@ namespace BAN
return true;
return m_inner_current == other.m_inner_current;
}
bool operator!=(const ConstIteratorDouble& other) const
bool operator!=(const IteratorDoubleGeneral& other) const
{
return !(*this == other);
}
@ -337,7 +183,7 @@ namespace BAN
}
private:
ConstIteratorDouble(Outer::const_iterator outer_end, Outer::const_iterator outer_current)
IteratorDoubleGeneral(const OuterIterator& outer_end, const OuterIterator& outer_current)
: m_outer_end(outer_end)
, m_outer_current(outer_current)
{
@ -360,11 +206,24 @@ namespace BAN
}
private:
Outer::const_iterator m_outer_end;
Outer::const_iterator m_outer_current;
Inner::const_iterator m_inner_current;
OuterIterator m_outer_end;
OuterIterator m_outer_current;
InnerIterator m_inner_current;
friend class IteratorDoubleGeneral<T, OuterContainer, InnerContainer, Container, !CONST>;
friend Container;
};
template<typename T, typename Container>
using IteratorSimple = IteratorSimpleGeneral<T, Container, false>;
template<typename T, typename Container>
using ConstIteratorSimple = IteratorSimpleGeneral<T, Container, true>;
template<typename T, template<typename> typename OuterContainer, template<typename> typename InnerContainer, typename Container>
using IteratorDouble = IteratorDoubleGeneral<T, OuterContainer, InnerContainer, Container, false>;
template<typename T, template<typename> typename OuterContainer, template<typename> typename InnerContainer, typename Container>
using ConstIteratorDouble = IteratorDoubleGeneral<T, OuterContainer, InnerContainer, Container, true>;
}