bintree_aa.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_CONTAINERS_BINTREE_AA_H
#define CPPCOMMON_CONTAINERS_BINTREE_AA_H
 
#include "bintree.h"
 
namespace CppCommon {
 
 
template <typename T, typename TCompare = std::less<T>>
class BinTreeAA
{
public:
    // Standard container type definitions
    typedef T value_type;
    typedef TCompare value_compare;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef ptrdiff_t difference_type;
    typedef size_t size_type;
    typedef BinTreeIterator<BinTreeAA<T, TCompare>, T> iterator;
    typedef BinTreeConstIterator<BinTreeAA<T, TCompare>, T> const_iterator;
    typedef BinTreeReverseIterator<BinTreeAA<T, TCompare>, T> reverse_iterator;
    typedef BinTreeConstReverseIterator<BinTreeAA<T, TCompare>, T> const_reverse_iterator;
 
    struct Node
    {
        T* parent;      
        T* left;        
        T* right;       
        size_t level;   
 
        Node() : parent(nullptr), left(nullptr), right(nullptr), level(0) {}
    };
 
    explicit BinTreeAA(const TCompare& compare = TCompare()) noexcept
        : _compare(compare),
          _size(0),
          _root(nullptr)
    {}
    template <class InputIterator>
    BinTreeAA(InputIterator first, InputIterator last, const TCompare& compare = TCompare()) noexcept;
    BinTreeAA(const BinTreeAA&) noexcept = default;
    BinTreeAA(BinTreeAA&&) noexcept = default;
    ~BinTreeAA() noexcept = default;
 
    BinTreeAA& operator=(const BinTreeAA&) noexcept = default;
    BinTreeAA& operator=(BinTreeAA&&) noexcept = default;
 
    explicit operator bool() const noexcept { return !empty(); }
 
    bool empty() const noexcept { return _root == nullptr; }
 
    size_t size() const noexcept { return _size; }
 
    T* root() noexcept { return _root; }
    const T* root() const noexcept { return _root; }
    T* lowest() noexcept;
    const T* lowest() const noexcept;
    T* highest() noexcept;
    const T* highest() const noexcept;
 
    bool compare(const T& item1, const T& item2) const noexcept { return _compare(item1, item2); }
 
    iterator begin() noexcept;
    const_iterator begin() const noexcept;
    const_iterator cbegin() const noexcept;
    iterator end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cend() const noexcept;
 
    reverse_iterator rbegin() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    const_reverse_iterator crbegin() const noexcept;
    reverse_iterator rend() noexcept;
    const_reverse_iterator rend() const noexcept;
    const_reverse_iterator crend() const noexcept;
 
    iterator find(const T& item) noexcept;
    const_iterator find(const T& item) const noexcept;
 
    iterator lower_bound(const T& item) noexcept;
    const_iterator lower_bound(const T& item) const noexcept;
    iterator upper_bound(const T& item) noexcept;
    const_iterator upper_bound(const T& item) const noexcept;
 
 
    std::pair<iterator, bool> insert(T& item) noexcept;
 
    std::pair<iterator, bool> insert(const const_iterator& position, T& item) noexcept;
 
 
    T* erase(const T& item) noexcept;
 
    iterator erase(const iterator& it) noexcept;
 
    void clear() noexcept;
 
    void swap(BinTreeAA& bintree) noexcept;
    template <typename U, typename UCompare>
    friend void swap(BinTreeAA<U, UCompare>& bintree1, BinTreeAA<U, UCompare>& bintree2) noexcept;
 
private:
    TCompare _compare;  // Binary tree compare
    size_t _size;       // Binary tree size
    T* _root;           // Binary tree root node
 
    const T* InternalLowest() const noexcept;
    const T* InternalHighest() const noexcept;
    const T* InternalFind(const T& item) const noexcept;
    const T* InternalLowerBound(const T& item) const noexcept;
    const T* InternalUpperBound(const T& item) const noexcept;
 
 
    void Skew(T* node);
 
    bool Split(T* node);
};
 
} // namespace CppCommon
 
#include "bintree_aa.inl"
 
#endif // CPPCOMMON_CONTAINERS_BINTREE_AA_H