CSIndexedSkipList.h

Go to the documentation of this file.


// Changes
// Random Access Container
// - return value for operator[] is mapped_type with Pair Associative Containers.

// DOCS for mainpage etc.





template <class T, class R = RNG>
class IndexedSkipList
{
public:
  class T0;
  class T1;
  friend class T0;
  friend class T1;
  typedef size_t size_type;

  typedef ptrdiff_t difference_type;
  typedef IndexedSkipList<T,R> container_type;

  typedef T value_type;
  typedef value_type mapped_type;
  typedef value_type& mapped_type_reference;
  typedef const value_type const_mapped_type;
  typedef const value_type& const_mapped_type_reference;
  typedef BidiIdxNode<value_type> node_type;

  typedef T0 iterator;
  typedef value_type* pointer;
  typedef value_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;

private:
  R rng; 
  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(size_type index) const{}


  void scan(const iterator &where) const{}


public:
  struct Prob
  {
    double probability; 
    unsigned int maxLevel; 

    explicit Prob(size_type maxNodes)  {}
    Prob(double probability, unsigned int maxLevel) {}
  };


  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){}


    reference operator*() const{}


    pointer 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{}


    size_type refresh(){}


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


    size_type getIndex() const{}
  };


  class T1 : public std::iterator<std::random_access_iterator_tag, value_type, ptrdiff_t, const value_type*, const 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){}


    reference operator*() const{}


    pointer 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{}


    size_type refresh(){}


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


    size_type getIndex() const{}

  };



  IndexedSkipList(){}


  IndexedSkipList(double probability, unsigned int maxLevel){}


  IndexedSkipList(const container_type &source){}


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


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


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


  explicit IndexedSkipList(size_type count) {}



  IndexedSkipList(size_type count, const T& val) {}


  IndexedSkipList(size_type count, const T& val, double probability, unsigned int maxLevel) {}


  IndexedSkipList(size_type count, const T& val, size_type maxNodes) {}


  IndexedSkipList(const Prob &prob) {}


  IndexedSkipList(size_type count, const Prob &prob) {}


  IndexedSkipList(size_type count, const T& val, const Prob &prob) {}


  template<class InIt> IndexedSkipList(InIt first, InIt last, const Prob &prob) {}


  ~IndexedSkipList(){}



  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 push_front(const value_type &val){}

  void pop_front(){}

  void destroy_front(){}


  void push_back(const value_type &val){}

  void pop_back(){}

  void destroy_back(){}


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



  void assign(size_type count, const T& val) {}


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


  void insert(const iterator &where, size_type count, const T& val){}


  template<class InIt> void insert(const iterator &where, 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){}


  iterator erase_index(size_type index);


  iterator destroy_index(size_type index);

  void resize(size_type newsize){}

  void resize(size_type newsize, const value_type &val){}


  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{}

  size_type max_size() const{}


  mapped_type& value(value_type& value) {}


  void reverse(){}


  void unique(){}


  template<class Pr2> void unique(Pr2 pred){}


  void sort(){}


  template<class Pr3> void sort(Pr3 pred){}


  void stable_sort(){}


  template<class Pr3> void stable_sort(Pr3 pred){}


  void erase_value(const value_type& val){}


  void splice(const iterator &where, container_type& right){}


  void splice(const iterator &where, container_type& right, iterator first){}


  void splice(const iterator &where, container_type& right, iterator first, iterator last){}
};


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

}


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


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


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


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


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


template <class T, class R = RNG>
class IndexedSSkipList
{
public:
  class T0;
  class T1;
  friend class T0;
  friend class T1;

  typedef size_t size_type;

  typedef ptrdiff_t difference_type;
  typedef IndexedSSkipList<T,R> container_type;

  typedef T value_type;
  typedef value_type mapped_type;
  typedef value_type& mapped_type_reference;
  typedef const value_type const_mapped_type;
  typedef const value_type& const_mapped_type_reference;
  typedef ForwardIdxNode<value_type> node_type;

  typedef T0 iterator;
  typedef value_type* pointer;
  typedef value_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;

private:
  R rng; 
  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(size_type index) const{}


  void scan(const iterator &where) const{}



public:

  struct Prob
  {
    double probability; 
    unsigned int maxLevel; 

    explicit Prob(size_type maxNodes)  {}
    Prob(double probability, unsigned int maxLevel) {}
  };


  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{}


    size_type 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{}


    size_type refresh(){}


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


    size_type getIndex() const{}

  };


  IndexedSSkipList(){}


  IndexedSSkipList(double probability, unsigned int maxLevel){}


  IndexedSSkipList(const container_type &source){}


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


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


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


  explicit IndexedSSkipList(size_type count) {}



  IndexedSSkipList(size_type count, const T& val) {}


  IndexedSSkipList(size_type count, const T& val, double probability, unsigned int maxLevel) {}


  IndexedSSkipList(size_type count, const T& val, size_type maxNodes) {}


  IndexedSSkipList(const Prob &prob) {}


  IndexedSSkipList(size_type count, const Prob &prob) {}


  IndexedSSkipList(size_type count, const T& val, const Prob &prob) {}


  template<class InIt> IndexedSSkipList(InIt first, InIt last, const Prob &prob) {}


  ~IndexedSSkipList(){}


  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 push_front(const value_type &val){}

  void pop_front(){}

  void destroy_front(){}


  void push_back(const value_type &val){}

  void pop_back(){}

  void destroy_back(){}


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



  void assign(size_type count, const T& val) {}


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


  void insert(const iterator &where, size_type count, const T& val){}


  template<class InIt> void insert(const iterator &where, 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){}


  iterator erase_index(size_type index);


  iterator destroy_index(size_type index);

  void resize(size_type newsize){}

  void resize(size_type newsize, const value_type &val){}


  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{}

  size_type max_size() const{}


  mapped_type& value(value_type& value) {}


  void reverse(){}


  void unique(){}


  template<class Pr2> void unique(Pr2 pred){}


  void sort(){}

  template<class Pr3> void sort(Pr3 pred){}


  void stable_sort(){}


  template<class Pr3> void stable_sort(Pr3 pred){}
//***


  void erase_value(const value_type& val){}


  void splice(const iterator &where, container_type& right){}


  void splice(const iterator &where, container_type& right, iterator first){}


  void splice(const iterator &where, container_type& right, iterator first, iterator last){}

};


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

}


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


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


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


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


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



template <class T, class R = RNG>
class IndexedTinySkipList
{
public:
  class T0;
  class T1;
  friend class T0;
  friend class T1;

  typedef size_t size_type;

  typedef ptrdiff_t difference_type;
  typedef IndexedTinySkipList<T,R> container_type;

  typedef T value_type;
  typedef value_type mapped_type;
  typedef value_type& mapped_type_reference;
  typedef const value_type const_mapped_type;
  typedef const value_type& const_mapped_type_reference;
  typedef ForwardTinyNode<value_type> node_type;

  typedef T0 iterator;
  typedef value_type* pointer;
  typedef value_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;

private:
  R rng; 
  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(size_type index) const{}


  void scan(const iterator &where) const{}

  struct Prob
  {
    double probability; 
    unsigned int maxLevel; 

    explicit Prob(size_type maxNodes)  {}
    Prob(double probability, unsigned int maxLevel) {}
  };


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{}


    size_type 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{}


    size_type refresh(){}


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


    size_type getIndex() const{}

  };


  IndexedTinySkipList(){}


  IndexedTinySkipList(double probability, unsigned int maxLevel){}


  IndexedTinySkipList(const container_type &source){}


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


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


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


  explicit IndexedTinySkipList(size_type count) {}



  IndexedTinySkipList(size_type count, const T& val) {}


  IndexedTinySkipList(size_type count, const T& val, double probability, unsigned int maxLevel) {}


  IndexedTinySkipList(size_type count, const T& val, size_type maxNodes) {}


  IndexedTinySkipList(const Prob &prob) {}


  IndexedTinySkipList(size_type count, const Prob &prob) {}


  IndexedTinySkipList(size_type count, const T& val, const Prob &prob) {}


  template<class InIt> IndexedTinySkipList(InIt first, InIt last, const Prob &prob) {}


  ~IndexedTinySkipList(){}


  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 push_front(const value_type &val){}

  void pop_front(){}

  void destroy_front(){}


  void push_back(const value_type &val){}

  void pop_back(){}

  void destroy_back(){}


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



  void assign(size_type count, const T& val) {}


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


  void insert(const iterator &where, size_type count, const T& val){}


  template<class InIt> void insert(const iterator &where, 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){}


  iterator erase_index(size_type index);


  iterator destroy_index(size_type index);

  void resize(size_type newsize){}

  void resize(size_type newsize, const value_type &val){}


  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{}

  size_type max_size() const{}


  mapped_type& value(value_type& value) {}


  void reverse(){}


  void unique(){}


  template<class Pr2> void unique(Pr2 pred){}


  void sort(){}

  template<class Pr3> void sort(Pr3 pred){}


  void stable_sort(){}


  template<class Pr3> void stable_sort(Pr3 pred){}


  void erase_value(const value_type& val){}


  void splice(const iterator &where, container_type& right){}


  void splice(const iterator &where, container_type& right, iterator first){}


  void splice(const iterator &where, container_type& right, iterator first, iterator last){}

};


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

}


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


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


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


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


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