329 lines
6.6 KiB
C++
329 lines
6.6 KiB
C++
/* ************************************************************************** */
|
|
/* */
|
|
/* ::: :::::::: */
|
|
/* bidirectionnal_iterator.hpp :+: :+: :+: */
|
|
/* +:+ +:+ +:+ */
|
|
/* By: apommier <apommier@student.42.fr> +#+ +:+ +#+ */
|
|
/* +#+#+#+#+#+ +#+ */
|
|
/* Created: 2022/11/22 14:50:53 by apommier #+# #+# */
|
|
/* Updated: 2022/11/27 21:22:24 by apommier ### ########.fr */
|
|
/* */
|
|
/* ************************************************************************** */
|
|
|
|
#pragma once
|
|
|
|
//#define _end 0
|
|
|
|
namespace ft
|
|
{
|
|
|
|
template<class T, class Node>
|
|
class bidirectionnal_iterator
|
|
{
|
|
public :
|
|
|
|
typedef T value_type;
|
|
typedef std::ptrdiff_t difference_type;
|
|
typedef T* pointer;
|
|
typedef const T* const_pointer;
|
|
typedef T& reference;
|
|
typedef const T& const_reference;
|
|
typedef bidirectionnal_iterator iterator_category;
|
|
typedef Node node;
|
|
typedef Node* NodePtr;
|
|
|
|
private :
|
|
|
|
NodePtr _root;
|
|
NodePtr _end;
|
|
NodePtr _node;
|
|
|
|
public :
|
|
|
|
bidirectionnal_iterator() : _root(NULL), _end(NULL), _node(NULL) {}
|
|
bidirectionnal_iterator(NodePtr root, NodePtr end, NodePtr node) : _root(root), _end(end), _node(node) { /*_end = NULL*/ }
|
|
bidirectionnal_iterator(bidirectionnal_iterator const &rhs) { *this = rhs; }
|
|
|
|
~bidirectionnal_iterator() {}
|
|
|
|
bidirectionnal_iterator &operator=(bidirectionnal_iterator const &rhs)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
this->_root = rhs._root;
|
|
this->_end = rhs._end;
|
|
this->_node = rhs._node;
|
|
}
|
|
return (*this);
|
|
}
|
|
|
|
operator bidirectionnal_iterator<const T, const Node>() const
|
|
{
|
|
return (bidirectionnal_iterator<const T, const Node>(_root, _end, _node));
|
|
}
|
|
|
|
NodePtr base() { return (_node); }
|
|
|
|
friend bool operator==(const bidirectionnal_iterator &rhs, const bidirectionnal_iterator &lhs)
|
|
{
|
|
if (!lhs._node && !rhs._node)
|
|
return (true);
|
|
else if (!lhs._node || !rhs._node)
|
|
return (false);
|
|
return (lhs._node->data == rhs._node->data);
|
|
// if (lhs._node && rhs._node)
|
|
// return (lhs._node->data == rhs._node->data);
|
|
// if (!lhs._node && !rhs._node)
|
|
// return (true);
|
|
// else
|
|
// return (false);
|
|
}
|
|
|
|
friend bool operator!=(const bidirectionnal_iterator &rhs, const bidirectionnal_iterator &lhs)
|
|
{
|
|
if (!lhs._node && !rhs._node)
|
|
return (false);
|
|
else if (!lhs._node || !rhs._node)
|
|
return (true);
|
|
return (lhs._node->data != rhs._node->data);
|
|
// if (lhs._node && rhs._node)
|
|
// return (lhs._node->data != rhs._node->data);
|
|
// if (!lhs._node && !rhs._node)
|
|
// return (true);
|
|
// else
|
|
// return (false);
|
|
}
|
|
|
|
reference operator*() { return (_node->data); }
|
|
const_reference operator*() const { return (_node->data); }
|
|
pointer operator->() { return (&(_node->data)); }
|
|
const_pointer operator->() const { return (&(_node->data)); }
|
|
|
|
|
|
|
|
bidirectionnal_iterator &operator++() {
|
|
//std::cout << "end == "<< _end << std::endl;
|
|
//std::cout << "node == "<< _node << std::endl;
|
|
if (_node != _end)
|
|
_node = successor(_node);
|
|
return (*this);
|
|
}
|
|
|
|
bidirectionnal_iterator operator++(int) {
|
|
bidirectionnal_iterator tmp(*this);
|
|
operator++();
|
|
return (tmp);
|
|
}
|
|
|
|
bidirectionnal_iterator &operator--() {
|
|
if (_node == _end) {
|
|
_node = maximum(_root);
|
|
}
|
|
else
|
|
_node = predecessor(_node);
|
|
return (*this);
|
|
}
|
|
|
|
bidirectionnal_iterator operator--(int) {
|
|
bidirectionnal_iterator tmp(*this);
|
|
operator--();
|
|
return (tmp);
|
|
}
|
|
|
|
|
|
NodePtr maximum(NodePtr ptr) {
|
|
while (ptr->right != _end)
|
|
ptr = ptr->right;
|
|
return (ptr);
|
|
}
|
|
|
|
NodePtr minimum(NodePtr ptr) {
|
|
while (ptr->left != _end)
|
|
ptr = ptr->left;
|
|
return (ptr);
|
|
}
|
|
|
|
NodePtr predecessor(NodePtr x) {
|
|
if (x->left != _end)
|
|
{
|
|
return maximum(x->left);
|
|
}
|
|
NodePtr y = x->parent;
|
|
while (y != NULL && x == y->left)
|
|
{
|
|
x = y;
|
|
y = y->parent;
|
|
}
|
|
return y;
|
|
}
|
|
|
|
NodePtr successor(NodePtr x) {
|
|
if (x->right != _end)
|
|
return minimum(x->right);
|
|
NodePtr y = x->parent;
|
|
while (y != NULL && x == y->right)
|
|
{
|
|
x = y;
|
|
y = y->parent;
|
|
}
|
|
if (y == NULL)
|
|
return _end;
|
|
return y;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// bidirectionnal_iterator &operator ++()
|
|
// {
|
|
// if (_node != NULL)
|
|
// _node = successor(_node);
|
|
// return (*this);
|
|
// }
|
|
|
|
// bidirectionnal_iterator operator ++(int)
|
|
// {
|
|
// bidirectionnal_iterator tmp(*this);
|
|
// ++(*this);
|
|
// return (tmp);
|
|
// }
|
|
|
|
// bidirectionnal_iterator &operator --()
|
|
// {
|
|
// if (_node == _end)
|
|
// _node = maximum(_root);
|
|
// else
|
|
// _node = predecessor(_node);
|
|
// return (*this);
|
|
// }
|
|
|
|
// bidirectionnal_iterator operator --(int)
|
|
// {
|
|
// bidirectionnal_iterator tmp(*this);
|
|
// --(*this);
|
|
// return (tmp);
|
|
// }
|
|
|
|
// NodePtr maximum(NodePtr ptr)
|
|
// {
|
|
// while (ptr && ptr->right != _end)
|
|
// ptr = ptr->right;
|
|
// return (ptr);
|
|
// }
|
|
|
|
// NodePtr minimum(NodePtr ptr)
|
|
// {
|
|
// while (ptr && ptr->left != _end)
|
|
// ptr = ptr->left;
|
|
// return (ptr);
|
|
// }
|
|
// NodePtr minimum(NodePtr node)
|
|
// {
|
|
// if (!node)
|
|
// return NULL;
|
|
// while (node->left->parent != NULL)
|
|
// node = node->left;
|
|
// return node;
|
|
// }
|
|
|
|
// NodePtr maximum(NodePtr node)
|
|
// {
|
|
// if (!node)
|
|
// return NULL;
|
|
// while (node->right->parent != NULL)
|
|
// node = node->right;
|
|
// return node;
|
|
// }
|
|
|
|
private :
|
|
|
|
// NodePtr predecessor(NodePtr x)
|
|
// {
|
|
// if (x->left != _end)
|
|
// {
|
|
// return maximum(x->left);
|
|
// }
|
|
// NodePtr y = x->parent;
|
|
// while (y != NULL && x == y->left)
|
|
// {
|
|
// x = y;
|
|
// y = y->parent;
|
|
// }
|
|
// return y;
|
|
// }
|
|
|
|
// NodePtr successor(NodePtr x)
|
|
// {
|
|
// if (!x)
|
|
// return (0);
|
|
// //std::cout << "_node: " << this->base() << std::endl;
|
|
// //std::cout << "succkey: " << x->data.first << " | succvalue: " << x->data.second << std::endl;
|
|
// if (x->right != _end)
|
|
// return minimum(x->right);
|
|
// NodePtr y = x->parent;
|
|
// while (y != NULL && x == y->right)
|
|
// {
|
|
// x = y;
|
|
// y = y->parent;
|
|
// }
|
|
// if (y == NULL)
|
|
// return _end;
|
|
// return y;
|
|
// }
|
|
|
|
|
|
|
|
// NodePtr successor(NodePtr x) {
|
|
// if (x->right != NULL) {
|
|
// return minimum(x->right);
|
|
// }
|
|
|
|
// NodePtr y = x->parent;
|
|
// while (y != NULL && x == y->right) {
|
|
// x = y;
|
|
// y = y->parent;
|
|
// }
|
|
// return y;
|
|
// }
|
|
|
|
// NodePtr predecessor(NodePtr x) {
|
|
// if (x->left != NULL) {
|
|
// return maximum(x->left);
|
|
// }
|
|
|
|
// NodePtr y = x->parent;
|
|
// while (y != NULL && x == y->left) {
|
|
// x = y;
|
|
// y = y->parent;
|
|
// }
|
|
|
|
// return y;
|
|
// }
|
|
};
|
|
|
|
} |