CSAutoSSkipList.h

Go to the documentation of this file.

template <class T, class Pr = std::less<T>, class R = RNG >
class AutoSSkipList
{
public:
  class T0;
  class T1;
  friend class T0;
  friend class T1;
  typedef size_t size_type;

  typedef ptrdiff_t difference_type;
  typedef T value_type;
  typedef ForwardIdxNode<value_type> node_type;
  typedef AutoSSkipList<T,Pr,R> container_type;
  typedef T key_type;

  typedef T0 iterator;
  typedef T* pointer;
  typedef T& reference;
  typedef T mapped_type;
  typedef T& mapped_type_reference;
  typedef const T const_mapped_type;
  typedef const T& const_mapped_type_reference;
  typedef const T& const_reference;
  typedef T1 const_iterator;

  typedef std::reverse_iterator<iterator> reverse_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  typedef std::pair<iterator, bool> slpair;
  typedef std::pair<iterator, iterator> ipair;
  typedef std::pair<const_iterator, const_iterator> const_ipair;
  typedef Pr key_compare;
  typedef Pr value_compare;

private:
  R rng; 
  Pr Compare; 
  unsigned int maxLevel; 
  unsigned int level;    
  node_type *head;  
  node_type *tail; 
  double probability; 
  size_type items; 
  mutable size_type scan_index; 
  mutable std::pair<size_type,node_type*> *update; 


  void Init(double probability,unsigned int maxLevel) {}


  node_type* Alloc(unsigned int level, const T &obj) {}


  node_type* Alloc(unsigned int level) {}


  void Free(node_type *item) {}


  unsigned int GenerateRandomLevel() const {}

  void adjust_levels() {}


  void scan(const value_type &val) const{}


  void scan(size_type index) const{}


  void scan(const node_type *nodex) const{}


  void scan(const iterator &where) const{}
public:


  class T0 : public std::iterator<std::random_access_iterator_tag, value_type>
  {
  public:
    typedef std::iterator<std::random_access_iterator_tag, value_type> baseclass;
    typedef std::random_acces_iterator_tag iterator_category;
    typedef typename baseclass::value_type value_type;
    typedef typename baseclass::value_type* pointer;
    typedef typename baseclass::value_type& reference;
    typedef ptrdiff_t difference_type;

    friend T1;
    friend container_type;
  private:
    container_type *container; 
    mutable size_type Findex; 
    node_type* node; 
  public:
    T0() {}


    T0(const T0 &t0){}


    T0(const T1 &t1){}


    T0(container_type *container, node_type* p){}


    T0(container_type *container, node_type* p, size_type index){}


    bool operator==(const T0& other) const{}


    bool operator!=(const T0& other) const{}


    bool operator==(const T1& other) const{}


    bool operator!=(const T1& other) const{}


    T0& operator++(){}


    T0 operator++(int){}


    T0& operator--(){}


    T0 operator--(int){}


    value_type& operator*() const{}


    value_type* operator->() const{}


    bool operator<(const T0 &other) const{}


    bool operator<=(const T0 &other) const{}


    bool operator>(const T0 &other) const{}


    bool operator>=(const T0 &other) const{}


    bool operator<(const T1 &other) const{}


    bool operator<=(const T1 &other) const{}


    bool operator>(const T1 &other) const{}


    bool operator>=(const T1 &other) const{}


    T0 operator+(difference_type off) const{}


    T0 operator-(difference_type off) const{}


    T0& operator+=(difference_type off){}


    T0& operator-=(difference_type off){}


    difference_type operator-(const T0 &other) const{}


    difference_type operator-(const T1 &other) const{}


    int refresh(){}


    value_type& operator[](difference_type off) const{}


    size_type getIndex() const{}
  };


  class T1 : public std::iterator<std::random_access_iterator_tag, value_type>
  {
  public:
    typedef std::iterator<std::random_access_iterator_tag, value_type> baseclass;
    typedef std::random_acces_iterator_tag iterator_category;
    typedef typename baseclass::value_type value_type;
    typedef typename const baseclass::value_type* pointer;
    typedef typename const baseclass::value_type& reference;
    typedef ptrdiff_t difference_type;

    friend T0;
    friend container_type;
  private:
    const container_type *container; 
    mutable size_type Findex; 
    const node_type* node; 
  public:
    T1() {}


    T1(const T1 &t1){}


    T1(const T0 &t0){}


    T1(container_type *container, node_type* p){}


    T1(container_type *container, node_type* p, size_type index){}


    bool operator==(const T0& other) const{}


    bool operator!=(const T0& other) const{}


    bool operator==(const T1& other) const{}


    bool operator!=(const T1& other) const{}


    T1& operator++(){}


    T1 operator++(int){}


    T1& operator--(){}


    T1 operator--(int){}


    value_type& operator*() const{}


    value_type* operator->() const{}


    bool operator<(const T0 &other) const{}


    bool operator<=(const T0 &other) const{}


    bool operator>(const T0 &other) const{}


    bool operator>=(const T0 &other) const{}


    bool operator<(const T1 &other) const{}


    bool operator<=(const T1 &other) const{}


    bool operator>(const T1 &other) const{}


    bool operator>=(const T1 &other) const{}


    T1 operator+(difference_type off) const{}


    T1 operator-(difference_type off) const{}


    T1& operator+=(difference_type off){}


    T1& operator-=(difference_type off){}


    difference_type operator-(const T0 &other) const{}


    difference_type operator-(const T1 &other) const{}


    int refresh(){}


    value_type& operator[](difference_type off) const{}


    size_type getIndex() const{}

  };


  AutoSSkipList(){}


  explicit AutoSSkipList(size_type maxNodes){}


  AutoSSkipList(double probability, unsigned int maxLevel){}


  AutoSSkipList(const container_type &source){}


  template<class InIt> AutoSSkipList(InIt first, InIt last){}


  template<class InIt> AutoSSkipList(InIt first, InIt last, double probability, unsigned int maxLevel){}


  template<class InIt> AutoSSkipList(InIt first, InIt last, size_type maxNodes){}


  explicit AutoSSkipList(const key_compare& comp){}


  template<class InIt> AutoSSkipList(InIt first, InIt last, const key_compare& comp){}


  template<class InIt> AutoSSkipList(InIt first, InIt last, const key_compare& comp, double probability, unsigned int maxLevel){}


  template<class InIt> AutoSSkipList(InIt first, InIt last, const key_compare& comp, size_type maxNodes) : Compare(comp){}


  ~AutoSSkipList(){}



  container_type& operator=(const container_type &source){}


  iterator begin(){}


  iterator end(){}


  const_iterator begin() const{}


  const_iterator end() const{}


  reverse_iterator rbegin(){}


  reverse_iterator rend(){}


  const_reverse_iterator rbegin() const{}


  const_reverse_iterator rend() const{}


  size_type size() const{}


  bool empty() const{}


  reference front(){}


  const_reference front() const{}


  reference back(){}


  const_reference back() const{}

  void pop_front(){}

  void destroy_front(){}

  void pop_back(){}

  void destroy_back(){}


  template<class InIt> void assign(InIt first, InIt last){}


  slpair insert(const value_type& val){}


  iterator insert(const iterator &where, const value_type& val) {}


  template<class InIt> void insert(InIt first, InIt last) {}

  void clear(){}

  void destroy(){}

  iterator erase(const iterator &where){}

  iterator destroy(const iterator &where){}


  iterator erase(const iterator &first, const iterator &last){}


  iterator destroy(const iterator &first, const iterator &last){}


  size_type erase(const key_type &keyval){}


  size_type destroy(const key_type &keyval){}


  iterator erase_index(size_type index);


  iterator destroy_index(size_type index);


  void swap(container_type& right) {}


  template<class Pr1> void erase_if(Pr1 pred);


  template<class Pr4> void destroy_if(Pr4 pred);


  void cut(const iterator &first, const iterator &last, container_type& right);


  mapped_type_reference operator[](size_type index){}


  const_mapped_type_reference operator[](size_type index) const{}


  mapped_type_reference at(size_type off){}


  const_mapped_type_reference at(size_type off) const{}

  key_compare key_comp() const { }

  value_compare value_comp() const { }

  size_type max_size() const{}


  const key_type& key(const value_type& value) const {}


  mapped_type& value(value_type& value) {}


  iterator find(const key_type& keyval) {}


  const_iterator find(const key_type& keyval) const {}


  size_type count(const key_type& keyval) const {}



  iterator lower_bound(const key_type& keyval) {}


  const_iterator lower_bound(const key_type& keyval) const {}


  iterator upper_bound(const key_type& keyval) {}


  const_iterator upper_bound(const key_type& keyval) const {}


  ipair equal_range(const key_type& keyval) {}


  const_ipair equal_range(const key_type& keyval) const {}
};


template <class T, class Pr, class R>
bool operator==(const AutoSSkipList<T,Pr,R> &left, const AutoSSkipList<T,Pr,R> &right)
{
  return ((left.size() == right.size()) &&
          (std::equal(left.begin(), left.end(), right.begin())));

}


template <class T, class Pr, class R>
bool operator!=(const AutoSSkipList<T,Pr,R> &left, const AutoSSkipList<T,Pr,R> &right)
{
  return !(left==right);
}


template <class T, class Pr, class R>
bool operator<(const AutoSSkipList<T,Pr,R> &left, const AutoSSkipList<T,Pr,R> &right)
{
  return lexicographical_compare(left.begin(),left.end(),right.begin(),right.end(),left.value_comp());
}


template <class T, class Pr, class R>
bool operator<=(const AutoSSkipList<T,Pr,R> &left, const AutoSSkipList<T,Pr,R> &right)
{
  return !(right < left);
}


template <class T, class Pr, class R>
bool operator>(const AutoSSkipList<T,Pr,R> &left, const AutoSSkipList<T,Pr,R> &right)
{
  return (right < left);
}


template <class T, class Pr, class R>
bool operator>=(const AutoSSkipList<T,Pr,R> &left, const AutoSSkipList<T,Pr,R> &right)
{
  return !(left < right);
}

/*#define csarg1 template <class T, class Pr, class R>
#define csarg2 AutoSSkipList<T,Pr,R>
CSDefineCompOps(csarg1, csarg2)
#undef csarg1
#undef csarg2

#undef CSUNIQUE
#define CSUNIQUE(a,b) b
*/


template <class T, class Pr = std::less<T>, class R = RNG >
class MultiAutoSSkipList
{
public:
  class T0;
  class T1;
  friend class T0;
  friend class T1;
  typedef size_t size_type;

  typedef ptrdiff_t difference_type;
  typedef T value_type;
  typedef ForwardIdxNode<value_type> node_type;
  typedef MultiAutoSSkipList<T,Pr,R> container_type;
  typedef T key_type;

  typedef T0 iterator;
  typedef T* pointer;
  typedef T& reference;
  typedef T mapped_type;
  typedef T& mapped_type_reference;
  typedef const T const_mapped_type;
  typedef const T& const_mapped_type_reference;
  typedef const T& const_reference;
  typedef T1 const_iterator;

  typedef std::reverse_iterator<iterator> reverse_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  typedef std::pair<iterator, iterator> ipair;
  typedef std::pair<const_iterator, const_iterator> const_ipair;
  typedef Pr key_compare;
  typedef Pr value_compare;

private:
  R rng; 
  Pr Compare; 
  unsigned int maxLevel; 
  unsigned int level;    
  node_type *head;  
  node_type *tail; 
  double probability; 
  size_type items; 
  mutable size_type scan_index; 
  mutable std::pair<size_type,node_type*> *update; 


  void Init(double probability, unsigned int maxLevel) {}


  node_type* Alloc(unsigned int level, const T &obj) {}


  node_type* Alloc(unsigned int level) {}


  void Free(node_type *item) {}


  unsigned int GenerateRandomLevel() const {}

  void adjust_levels() {}


  void scan(const value_type &val) const{}


  void scan(size_type index) const{}


  void scan(const node_type *nodex) const{}


  void scan(const iterator &where) const{}

public:

  class T0 : public std::iterator<std::random_access_iterator_tag, value_type>
  {
  public:
    typedef std::iterator<std::random_access_iterator_tag, value_type> baseclass;
    typedef std::random_acces_iterator_tag iterator_category;
    typedef typename baseclass::value_type value_type;
    typedef typename baseclass::value_type* pointer;
    typedef typename baseclass::value_type& reference;
    typedef ptrdiff_t difference_type;

    friend T1;
    friend container_type;
  private:
    container_type *container; 
    mutable size_type Findex; 
    node_type* node; 
  public:
    T0() {}


    T0(const T0 &t0){}


    T0(const T1 &t1){}


    T0(container_type *container, node_type* p){}


    T0(container_type *container, node_type* p, size_type index){}


    bool operator==(const T0& other) const{}


    bool operator!=(const T0& other) const{}


    bool operator==(const T1& other) const{}


    bool operator!=(const T1& other) const{}


    T0& operator++(){}


    T0 operator++(int){}


    T0& operator--(){}


    T0 operator--(int){}


    value_type& operator*() const{}


    value_type* operator->() const{}


    bool operator<(const T0 &other) const{}


    bool operator<=(const T0 &other) const{}


    bool operator>(const T0 &other) const{}


    bool operator>=(const T0 &other) const{}


    bool operator<(const T1 &other) const{}


    bool operator<=(const T1 &other) const{}


    bool operator>(const T1 &other) const{}


    bool operator>=(const T1 &other) const{}


    T0 operator+(difference_type off) const{}


    T0 operator-(difference_type off) const{}


    T0& operator+=(difference_type off){}


    T0& operator-=(difference_type off){}


    difference_type operator-(const T0 &other) const{}


    difference_type operator-(const T1 &other) const{}


    int refresh(){}


    value_type& operator[](difference_type off) const{}


    size_type getIndex() const{}
  };


  class T1 : public std::iterator<std::random_access_iterator_tag, value_type>
  {
  public:
    typedef std::iterator<std::random_access_iterator_tag, value_type> baseclass;
    typedef std::random_acces_iterator_tag iterator_category;
    typedef typename baseclass::value_type value_type;
    typedef typename const baseclass::value_type* pointer;
    typedef typename const baseclass::value_type& reference;
    typedef ptrdiff_t difference_type;

    friend T0;
    friend container_type;
  private:
    const container_type *container; 
    mutable size_type Findex; 
    const node_type* node; 
  public:
    T1() {}


    T1(const T1 &t1){}


    T1(const T0 &t0){}


    T1(container_type *container, node_type* p){}


    T1(container_type *container, node_type* p, size_type index){}


    bool operator==(const T0& other) const{}


    bool operator!=(const T0& other) const{}


    bool operator==(const T1& other) const{}


    bool operator!=(const T1& other) const{}


    T1& operator++(){}


    T1 operator++(int){}


    T1& operator--(){}


    T1 operator--(int){}


    value_type& operator*() const{}


    value_type* operator->() const{}


    bool operator<(const T0 &other) const{}


    bool operator<=(const T0 &other) const{}


    bool operator>(const T0 &other) const{}


    bool operator>=(const T0 &other) const{}


    bool operator<(const T1 &other) const{}


    bool operator<=(const T1 &other) const{}


    bool operator>(const T1 &other) const{}


    bool operator>=(const T1 &other) const{}


    T1 operator+(difference_type off) const{}


    T1 operator-(difference_type off) const{}


    T1& operator+=(difference_type off){}


    T1& operator-=(difference_type off){}


    difference_type operator-(const T0 &other) const{}


    difference_type operator-(const T1 &other) const{}


    int refresh(){}


    value_type& operator[](difference_type off) const{}


    size_type getIndex() const{}

  };



  MultiAutoSSkipList(){}


  explicit MultiAutoSSkipList(size_type maxNodes){}


  MultiAutoSSkipList(double probability, unsigned int maxLevel){}


  MultiAutoSSkipList(const container_type &source){}


  template<class InIt> MultiAutoSSkipList(InIt first, InIt last){}


  template<class InIt> MultiAutoSSkipList(InIt first, InIt last, double probability, unsigned int maxLevel){}


  template<class InIt> MultiAutoSSkipList(InIt first, InIt last, size_type maxNodes){}


  explicit MultiAutoSSkipList(const key_compare& comp){}


  template<class InIt> MultiAutoSSkipList(InIt first, InIt last, const key_compare& comp){}


  template<class InIt> MultiAutoSSkipList(InIt first, InIt last, const key_compare& comp, double probability, unsigned int maxLevel){}


  template<class InIt> MultiAutoSSkipList(InIt first, InIt last, const key_compare& comp, size_type maxNodes) : Compare(comp){}


  ~MultiAutoSSkipList(){}



  container_type& operator=(const container_type &source){}


  iterator begin(){}


  iterator end(){}


  const_iterator begin() const{}


  const_iterator end() const{}


  reverse_iterator rbegin(){}


  reverse_iterator rend(){}


  const_reverse_iterator rbegin() const{}


  const_reverse_iterator rend() const{}


  size_type size() const{}


  bool empty() const{}


  reference front(){}


  const_reference front() const{}


  reference back(){}


  const_reference back() const{}

  void pop_front(){}

  void destroy_front(){}

  void pop_back(){}

  void destroy_back(){}


  template<class InIt> void assign(InIt first, InIt last){}


  iterator insert(const value_type& val){}


  iterator insert(const iterator &where, const value_type& val) {}


  template<class InIt> void insert(InIt first, InIt last) {}

  void clear(){}

  void destroy(){}

  iterator erase(const iterator &where){}

  iterator destroy(const iterator &where){}


  iterator erase(const iterator &first, const iterator &last){}


  iterator destroy(const iterator &first, const iterator &last){}


  size_type erase(const key_type &keyval){}


  size_type destroy(const key_type &keyval){}


  iterator erase_index(size_type index);


  iterator destroy_index(size_type index);


  void swap(container_type& right) {}


  template<class Pr1> void erase_if(Pr1 pred);


  template<class Pr4> void destroy_if(Pr4 pred);


  void cut(const iterator &first, const iterator &last, container_type& right);


  mapped_type_reference operator[](size_type index){}


  const_mapped_type_reference operator[](size_type index) const{}


  mapped_type_reference at(size_type off){}


  const_mapped_type_reference at(size_type off) const{}

  key_compare key_comp() const { }

  value_compare value_comp() const { }

  size_type max_size() const{}


  const key_type& key(const value_type& value) const {}


  mapped_type& value(value_type& value) {}


  iterator find(const key_type& keyval) {}


  const_iterator find(const key_type& keyval) const {}


  size_type count(const key_type& keyval) const {}



  iterator lower_bound(const key_type& keyval) {}


  const_iterator lower_bound(const key_type& keyval) const {}


  iterator upper_bound(const key_type& keyval) {}


  const_iterator upper_bound(const key_type& keyval) const {}


  ipair equal_range(const key_type& keyval) {}


  const_ipair equal_range(const key_type& keyval) const {}
};


template <class T, class Pr, class R>
bool operator==(const MultiAutoSSkipList<T,Pr,R> &left, const MultiAutoSSkipList<T,Pr,R> &right)
{
  return ((left.size() == right.size()) &&
          (std::equal(left.begin(), left.end(), right.begin())));
}


template <class T, class Pr, class R>
bool operator!=(const MultiAutoSSkipList<T,Pr,R> &left, const MultiAutoSSkipList<T,Pr,R> &right)
{
  return !(left==right);
}


template <class T, class Pr, class R>
bool operator<(const MultiAutoSSkipList<T,Pr,R> &left, const MultiAutoSSkipList<T,Pr,R> &right)
{
  return lexicographical_compare(left.begin(),left.end(),right.begin(),right.end(),left.value_comp());
}


template <class T, class Pr, class R>
bool operator<=(const MultiAutoSSkipList<T,Pr,R> &left, const MultiAutoSSkipList<T,Pr,R> &right)
{
  return !(right < left);
}


template <class T, class Pr, class R>
bool operator>(const MultiAutoSSkipList<T,Pr,R> &left, const MultiAutoSSkipList<T,Pr,R> &right)
{
  return (right < left);
}


template <class T, class Pr, class R>
bool operator>=(const MultiAutoSSkipList<T,Pr,R> &left, const MultiAutoSSkipList<T,Pr,R> &right)
{
  return !(left < right);
}


/*#define csarg1 template <class T, class Pr, class R>
#define csarg2 MultiAutoSSkipList<T,Pr,R>
CSDefineCompOps(csarg1, csarg2)
#undef csarg1
#undef csarg2
*/