42/42_INT_11_ft_containers
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

small clean up of the files

Browse Source
This commit is contained in:
hugogogo
2022-06-29 14:42:03 +02:00
parent eeb3c7dfc0
commit 38804caea9
17 changed files with 0 additions and 836 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
builds_ft/main.d
View File

@@ -1,8 +0,0 @@
builds_ft/main.o: tests/main.cpp tests/includes/main.hpp headers/colors.h \
tests/includes/tests_structs.hpp
tests/includes/main.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:

9
builds_ft/tests_definitions.d
View File

@@ -1,9 +0,0 @@
builds_ft/tests_definitions.o: tests/tests_definitions.cpp \
tests/includes/tests_utils.hpp headers/colors.h \
tests/includes/tests_structs.hpp
tests/includes/tests_utils.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:

32
builds_ft/tests_map.d
View File

@@ -1,32 +0,0 @@
builds_ft/tests_map.o: tests/tests_map.cpp tests/includes/tests_map.hpp \
tests/includes/tests_utils.hpp headers/colors.h \
tests/includes/tests_structs.hpp headers/map.hpp \
headers/reverse_iterator.hpp headers/iterator_traits.hpp \
headers/equal.hpp headers/lexicographical_compare.hpp headers/pair.hpp \
headers/map_node.hpp headers/map_iterator.hpp templates/map.tpp
tests/includes/tests_map.hpp:
tests/includes/tests_utils.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:
headers/map.hpp:
headers/reverse_iterator.hpp:
headers/iterator_traits.hpp:
headers/equal.hpp:
headers/lexicographical_compare.hpp:
headers/pair.hpp:
headers/map_node.hpp:
headers/map_iterator.hpp:
templates/map.tpp:

33
builds_ft/tests_stack.d
View File

@@ -1,33 +0,0 @@
builds_ft/tests_stack.o: tests/tests_stack.cpp \
tests/includes/tests_stack.hpp tests/includes/tests_utils.hpp \
headers/colors.h tests/includes/tests_structs.hpp headers/stack.hpp \
headers/vector.hpp headers/enable_if.hpp headers/is_integral.hpp \
headers/reverse_iterator.hpp headers/iterator_traits.hpp \
headers/equal.hpp headers/lexicographical_compare.hpp \
templates/vector.tpp
tests/includes/tests_stack.hpp:
tests/includes/tests_utils.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:
headers/stack.hpp:
headers/vector.hpp:
headers/enable_if.hpp:
headers/is_integral.hpp:
headers/reverse_iterator.hpp:
headers/iterator_traits.hpp:
headers/equal.hpp:
headers/lexicographical_compare.hpp:
templates/vector.tpp:

31
builds_ft/tests_vector.d
View File

@@ -1,31 +0,0 @@
builds_ft/tests_vector.o: tests/tests_vector.cpp \
tests/includes/tests_vector.hpp tests/includes/tests_utils.hpp \
headers/colors.h tests/includes/tests_structs.hpp headers/vector.hpp \
headers/enable_if.hpp headers/is_integral.hpp \
headers/reverse_iterator.hpp headers/iterator_traits.hpp \
headers/equal.hpp headers/lexicographical_compare.hpp \
templates/vector.tpp
tests/includes/tests_vector.hpp:
tests/includes/tests_utils.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:
headers/vector.hpp:
headers/enable_if.hpp:
headers/is_integral.hpp:
headers/reverse_iterator.hpp:
headers/iterator_traits.hpp:
headers/equal.hpp:
headers/lexicographical_compare.hpp:
templates/vector.tpp:

8
builds_stl/main.d
View File

@@ -1,8 +0,0 @@
builds_stl/main.o: tests/main.cpp tests/includes/main.hpp \
headers/colors.h tests/includes/tests_structs.hpp
tests/includes/main.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:

9
builds_stl/tests_definitions.d
View File

@@ -1,9 +0,0 @@
builds_stl/tests_definitions.o: tests/tests_definitions.cpp \
tests/includes/tests_utils.hpp headers/colors.h \
tests/includes/tests_structs.hpp
tests/includes/tests_utils.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:

11
builds_stl/tests_map.d
View File

@@ -1,11 +0,0 @@
builds_stl/tests_map.o: tests/tests_map.cpp tests/includes/tests_map.hpp \
tests/includes/tests_utils.hpp headers/colors.h \
tests/includes/tests_structs.hpp
tests/includes/tests_map.hpp:
tests/includes/tests_utils.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:

11
builds_stl/tests_stack.d
View File

@@ -1,11 +0,0 @@
builds_stl/tests_stack.o: tests/tests_stack.cpp \
tests/includes/tests_stack.hpp tests/includes/tests_utils.hpp \
headers/colors.h tests/includes/tests_structs.hpp
tests/includes/tests_stack.hpp:
tests/includes/tests_utils.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:

11
builds_stl/tests_vector.d
View File

@@ -1,11 +0,0 @@
builds_stl/tests_vector.o: tests/tests_vector.cpp \
tests/includes/tests_vector.hpp tests/includes/tests_utils.hpp \
headers/colors.h tests/includes/tests_structs.hpp
tests/includes/tests_vector.hpp:
tests/includes/tests_utils.hpp:
headers/colors.h:
tests/includes/tests_structs.hpp:

BIN
containers_ft
View File

Binary file not shown.

BIN
containers_stl
View File

Binary file not shown.

187
headers/bak__bst.hpp
View File

@@ -1,187 +0,0 @@
#ifndef BST_HPP
# define BST_HPP
# include <memory> // std::allocator
# include <cstddef> // NULL, size_t, ptrdiff_t
# include <algorithm> // max()
# include <functional> // std::less()
# include "reverse_iterator.hpp"
# include "equal.hpp"
# include "lexicographical_compare.hpp"
# include "pair.hpp"
# include "bst_node.hpp"
# include "bst_iterator.hpp"
namespace ft {
template <
typename Key,
typename T,
typename Compare = std::less<Key>,
typename Allocator = std::allocator< ft::pair<const Key, T> >
> class Bst {
public:
typedef Key key_type;
typedef T mapped_type;
typedef pair<const Key, T> value_type;
typedef Compare key_compare;
typedef Allocator allocator_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef Bst_iterator<Key, T, Compare, Allocator> iterator;
typedef Bst_const_iterator<Key, T, Compare, Allocator> const_iterator;
typedef ft::reverse_iterator<iterator> reverse_iterator;
typedef ft::reverse_iterator<const_iterator> const_reverse_iterator;
/************
* copliens :
************/
// constructors ------------------------------
explicit Bst(
const key_compare& comp = Compare(),
const Allocator& alloc = Allocator()
);
template < typename InputIt >
Bst(
InputIt first, InputIt last,
const key_compare& comp = Compare(),
const allocator_type& alloc = Allocator()
);
Bst(const Bst& src);
// destructor --------------------------------
~Bst();
// operator= ---------------------------------
Bst& operator=(const Bst& rhs);
/*************
* iterators :
*************/
// begin -------------------------------------
iterator begin();
const_iterator begin() const;
// end ---------------------------------------
iterator end();
const_iterator end() const;
// rbegin ------------------------------------
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
// rend --------------------------------------
reverse_iterator rend();
const_reverse_iterator rend() const;
/************
* capacity :
************/
// empty -------------------------------------
bool empty() const;
// size --------------------------------------
size_type size() const;
// max_size ----------------------------------
size_type max_size() const;
/******************
* element access :
******************/
// operator[] --------------------------------
mapped_type& operator[](const key_type& key);
/*************
* modifiers :
*************/
// insert ------------------------------------
pair<iterator, bool> insert(const value_type& value);
iterator insert(iterator hint, const value_type& value);
template < typename InputIt >
void insert(InputIt first, InputIt last);
// erase -------------------------------------
void erase(iterator pos);
size_type erase(const key_type& key);
void erase(iterator first, iterator last);
// swap --------------------------------------
void swap(Bst& other);
// clear -------------------------------------
void clear();
/**************
* operations :
**************/
// find --------------------------------------
iterator find(const key_type& key);
const_iterator find(const key_type& key) const;
// count -------------------------------------
size_type count(const key_type& key) const;
private:
size_type _size;
node<value_type>* _root;
node_sentinel<value_type>* _sentinel;
Compare _comp;
Allocator _allocator;
// https://stackoverflow.com/questions/14148756/what-does-template-rebind-do
typename Allocator::template
rebind< node<value_type> >::other _allocator_node;
typename Allocator::template
rebind< node_sentinel<value_type> >::other _allocator_node_sentinel;
void _init_sentinel();
pair<iterator, bool> _insert(const value_type& value);
node<value_type>* _erase(iterator pos);
node<value_type>* _subtree_shift(
node<value_type>* st_old,
node<value_type>* st_new
);
// BBST
// https://www.youtube.com/watch?v=vRwi_UcZGjU
void _insert_rebalancing(node<value_type>* n);
void _erase_rebalancing(node<value_type>* n);
short _compute_height(node<value_type>* n);
short _balance_factor(node<value_type>* n);
node<value_type>* _rotate_left(node<value_type>* n);
node<value_type>* _rotate_right(node<value_type>* n);
};
// Non-member functions
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator==(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator!=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator<(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator>(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator<=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
bool operator>=(const Bst<Key,T,Compare,Alloc>& lhs, const Bst<Key,T,Compare,Alloc>& rhs);
template < typename Key, typename T, typename Compare, typename Alloc >
void swap(Bst<Key,T,Compare,Alloc>& lhs, Bst<Key,T,Compare,Alloc>& rhs);
} // namespace ft
# include "bst.tpp"
// https://en.wikipedia.org/wiki/Binary_search_tree
// https://en.wikipedia.org/wiki/AVL_tree
// https://fr.wikipedia.org/wiki/Arbre_binaire_de_recherche
// https://fr.wikipedia.org/wiki/Arbre_AVL
// https://visualgo.net/en/bst
// https://visualgo.net/en/bst?slide=14-8 // --> to 14-13
#endif

207
headers/bak__bst_iterator.hpp
View File

@@ -1,207 +0,0 @@
#ifndef BST_ITERATOR_HPP
# define BST_ITERATOR_HPP
# include <cstddef> // NULL, ptrdiff_t
# include <iterator> // iterator_tag
# include "pair.hpp"
# include "bst_node.hpp"
namespace ft {
template <
typename Key,
typename T,
typename Compare,
typename Allocator
> class Bst_iterator
{
private:
typedef Bst_iterator Self;
public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef pair<const Key, T> value_type;
typedef std::ptrdiff_t difference_type;
typedef value_type* pointer;
typedef value_type& reference;
Bst_iterator() : _node(), _sentinel() {}
Bst_iterator(node<value_type>* n, node_sentinel<value_type>* sentinel) : _node(n), _sentinel(sentinel) {}
//Bst_iterator(const Bst_iterator& src) : _node(src._node), _sentinel(src._sentinel) {} //implicit
reference operator*() const
{ return _node->value; }
pointer operator->() const
{ return &_node->value; }
Self& operator++()
{
if (_node == NULL)
_node = _sentinel->child->min();
else if (_node->right)
_node = _node->right->min();
else
{
node<value_type>* up = _node->up;
while (up != NULL && _node == up->right)
{
_node = up;
up = up->up;
}
_node = up;
}
return *this;
}
Self& operator--()
{
if (_node == NULL)
_node = _sentinel->child->max();
else if (_node->left)
_node = _node->left->max();
else
{
node<value_type>* up = _node->up;
while (up != NULL && _node == up->left)
{
_node = up;
up = up->up;
}
_node = up;
}
return *this;
}
Self operator++(int)
{
//Self old(*this);
Self old = *this;
++(*this);
return old;
}
Self operator--(int)
{
//Self old(*this);
Self old = *this;
--(*this);
return old;
}
node<value_type>* getNode()
{ return _node; }
const node<value_type>* getNode() const
{ return _node; }
const node_sentinel<value_type>* getSentinel() const
{ return _sentinel; }
// TODO : friend Non-member functions syntaxe pas clair.
friend bool operator==(const Self &lhs, const Self &rhs)
{ return lhs._node == rhs._node; }
friend bool operator!=(const Self &lhs, const Self &rhs)
{ return !(lhs._node == rhs._node); }
private:
node<value_type>* _node;
node_sentinel<value_type>* _sentinel;
};
template <
typename Key,
typename T,
typename Compare,
typename Allocator
> class Bst_const_iterator
{
private:
typedef Bst_const_iterator Self;
public:
typedef std::bidirectional_iterator_tag iterator_category;
typedef pair<const Key, T> value_type;
typedef std::ptrdiff_t difference_type;
typedef const value_type* pointer;
typedef const value_type& reference;
Bst_const_iterator() : _node(), _sentinel() {}
Bst_const_iterator(const node<value_type>* node, const node_sentinel<value_type>* sentinel) : _node(node), _sentinel(sentinel) {}
//Bst_const_iterator(const Bst_const_iterator& src) : _node(src._node), _sentinel(src._sentinel) {} //implicit
Bst_const_iterator(const Bst_iterator<Key, T, Compare, Allocator>& src) : _node(src.getNode()), _sentinel(src.getSentinel()) {}
reference operator*() const
{ return _node->value; }
pointer operator->() const
{ return &_node->value; }
Self& operator++()
{
if (_node == NULL)
_node = _sentinel->child->min();
else if (_node->right)
_node = _node->right->min();
else
{
node<value_type>* up = _node->up;
while (up != NULL && _node == up->right)
{
_node = up;
up = up->up;
}
_node = up;
}
return *this;
}
Self& operator--()
{
if (_node == NULL)
_node = _sentinel->child->max();
else if (_node->left)
_node = _node->left->max();
else
{
node<value_type>* up = _node->up;
while (up != NULL && _node == up->left)
{
_node = up;
up = up->up;
}
_node = up;
}
return *this;
}
Self operator++(int)
{
//Self old(*this);
Self old = *this;
++(*this);
return old;
}
Self operator--(int)
{
//Self old(*this);
Self old = *this;
--(*this);
return old;
}
node<value_type>* getNode() const
{ return _node; }
friend bool operator==(const Self &lhs, const Self &rhs)
{ return lhs._node == rhs._node; }
friend bool operator!=(const Self &lhs, const Self &rhs)
{ return !(lhs._node == rhs._node); }
private:
const node<value_type>* _node;
const node_sentinel<value_type>* _sentinel;
};
} // namespace ft
#endif

50
headers/bak__bst_node.hpp
View File

@@ -1,50 +0,0 @@
#ifndef BST_NODE_HPP
# define BST_NODE_HPP
# include <cstddef> // NULL
namespace ft {
template < typename ValueType >
struct node
{
ValueType value;
node *up;
node *left;
node *right;
short height;
node(const ValueType& val) : value(val), up(NULL), left(NULL), right(NULL), height(1) {}
node* min()
{
node* n = this;
while (n->left)
n = n->left;
return n;
}
node* max()
{
node* n = this;
while (n->right)
n = n->right;
return n;
}
};
template < typename ValueType >
struct node_sentinel
{
node<ValueType> *child;
node_sentinel() : child(NULL) {}
};
} // namespace ft
#endif

207
headers/bak__map.hpp
View File

@@ -1,207 +0,0 @@
#ifndef MAP_HPP
# define MAP_HPP
# include <memory> // std::allocator
# include <cstddef> // NULL, std::size_t, std::ptrdiff_t
# include <functional> // std::less, std::binary_function
# include "pair.hpp"
# include "bst.hpp"
namespace ft {
template <
class Key, // map::key_type
class T, // map::mapped_type
class Compare = std::less<Key>, // map::key_compare
class Alloc = std::allocator< ft::pair<const Key, T> > // map::allocator_type
> class map {
public:
typedef Key key_type;
typedef T mapped_type;
typedef pair<const Key, T> value_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef Compare key_compare;
typedef Alloc allocator_type;
typedef Bst<Key,T,Compare,Alloc> bst_map;
typedef typename bst_map::iterator iterator;
typedef typename bst_map::const_iterator const_iterator;
typedef typename bst_map::reverse_iterator reverse_iterator;
typedef typename bst_map::const_reverse_iterator const_reverse_iterator;
/****************
* member class :
****************/
// https://en.cppreference.com/w/cpp/container/map/value_compare
// https://stackoverflow.com/questions/4571355/why-would-one-use-nested-classes-in-c
class value_compare : public std::binary_function<value_type, value_type, bool> {
friend class map;
protected:
Compare comp;
value_compare(Compare c) : comp(c) {}
public:
bool operator() (const value_type& x, const value_type& y) const
{ return comp(x.first, y.first); }
};
/************
* copliens :
************/
// constructors ------------------------------
explicit map (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
template <class InputIterator>
map (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
map (const map& x);
// destructor --------------------------------
~map();
// operator= ---------------------------------
map& operator= (const map& x);
/*************
* iterators :
*************/
// begin -------------------------------------
iterator begin();
const_iterator begin() const;
// end ---------------------------------------
iterator end();
const_iterator end() const;
// rbegin ------------------------------------
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
// rend --------------------------------------
reverse_iterator rend();
const_reverse_iterator rend() const;
/************
* capacity :
************/
// empty -------------------------------------
bool empty() const;
// size --------------------------------------
size_type size() const;
// max_size ----------------------------------
size_type max_size() const;
/******************
* element access :
******************/
// operator[] --------------------------------
mapped_type & operator[] (const key_type& k);
/*************
* modifiers :
*************/
// insert ------------------------------------
pair<iterator,bool> insert (const value_type& val);
iterator insert (iterator position, const value_type& val);
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
// erase -------------------------------------
void erase (iterator position);
size_type erase (const key_type& k);
void erase (iterator first, iterator last);
// swap --------------------------------------
void swap (map& x);
// clear -------------------------------------
void clear();
/*************
* observers :
*************/
// key_comp ----------------------------------
key_compare key_comp() const;
// value_comp --------------------------------
value_compare value_comp() const;
/**************
* operations :
**************/
// find --------------------------------------
iterator find (const key_type& k);
const_iterator find (const key_type& k) const;
// count -------------------------------------
size_type count (const key_type& k) const;
// lower_bound -------------------------------
iterator lower_bound (const key_type& k);
const_iterator lower_bound (const key_type& k) const;
// upper_bound -------------------------------
iterator upper_bound (const key_type& k);
const_iterator upper_bound (const key_type& k) const;
// equal_range -------------------------------
pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator> equal_range (const key_type& k);
/*************
* allocator :
*************/
// get_allocator -----------------------------
allocator_type get_allocator() const;
// TMP non privat
bst_map _bst;
private:
allocator_type _allocator;
key_compare _comp;
};
/************************
* non-member functions :
************************/
// operator == -------------------------------
template< class K, class T, class Comp, class Alloc > bool operator==
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
// operator != -------------------------------
template< class K, class T, class Comp, class Alloc > bool operator!=
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
// operator < --------------------------------
template< class K, class T, class Comp, class Alloc > bool operator<
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
// operator <= -------------------------------
template< class K, class T, class Comp, class Alloc > bool operator<=
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
// operator > --------------------------------
template< class K, class T, class Comp, class Alloc > bool operator>
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
// operator >= -------------------------------
template< class K, class T, class Comp, class Alloc > bool operator>=
( const std::map<K,T,Comp,Alloc>& lhs, const std::map<K,T,Comp,Alloc>& rhs );
// swap (map) -----------------------------
template< class Key, class T, class Compare, class Alloc > void swap
( std::map<Key,T,Compare,Alloc>& lhs, std::map<Key,T,Compare,Alloc>& rhs );
} // namespace ft
# include "map.tpp"
// banlanced binary search tree :
// https://www.youtube.com/watch?v=vRwi_UcZGjU
// entinel node :
// https://en.wikipedia.org/wiki/Sentinel_node
#endif

22
tests/includes/tests_mutant_stack.hpp
View File

@@ -1,22 +0,0 @@
#ifndef TESTS_MUTANT_STACK_HPP
# define TESTS_MUTANT_STACK_HPP
#include <stack>
template <typename T>
class MutantStack : public std::stack<T> {
public:
typedef typename std::stack<T>::container_type::iterator iterator;
typedef typename std::stack<T>::container_type::const_iterator const_iterator;
iterator begin() {return this->c.begin();}
iterator end() {return this->c.end();}
const_iterator begin() const {return this->c.begin();}
const_iterator end() const {return this->c.end();}
};
#endif