---

vgtl_intadapt.h

Go to the documentation of this file.

// Internal iterator adaptors implementation -*- C++ -*-

// Copyright (C) 2001-2003 Hermann Schichl
//
// This file is part of the Vienna Graph Template Library.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef __VGTL_INTADAPT_H_
#define __VGTL_INTADAPT_H_

#include <vgtl_helpers.h>

__VGTL_BEGIN_NAMESPACE

// adaptors for (multi)set and (multi)map associative container trees

template <class _Compare>
class pointer_adaptor : public _Compare
{
  private:
    typedef pointer_adaptor<_Compare> _Self;
    typedef typename _Compare::first_argument_type __a1;
    typedef typename _Compare::second_argument_type __a2;

  public:

    typedef __a1* first_argument_type;
    typedef __a2* second_argument_type;
    typedef typename _Compare::result_type result_type;
    
  public:
    result_type operator()(__a1* arg1, __a2* arg2) const
        { return _Compare(*arg1, *arg2); }
};


template <class _Iterator>
class pair_adaptor
{
  private:
    typedef pair_adaptor<_Iterator> _Self;
       
  public:

    typedef typename std::iterator_traits<_Iterator>::iterator_category iterator_category;
    typedef typename std::iterator_traits<_Iterator>::difference_type difference_type;
    typedef typename std::iterator_traits<_Iterator>::value_type p_value_type;
    typedef typename std::iterator_traits<_Iterator>::pointer p_pointer;
    typedef typename std::iterator_traits<_Iterator>::reference p_reference;

    typedef typename p_value_type::second_type value_type;
    typedef value_type& reference;
    typedef value_type* pointer;


    typedef typename p_value_type::first_type key_type;
    typedef key_type& key_reference;
    typedef key_type* key_pointer;
                 
    typedef _Iterator iterator_type;
  protected:
    _Iterator current;

  public:
    pair_adaptor() : current() {}
    explicit pair_adaptor(iterator_type __x) : current(__x) {}

    pair_adaptor(const _Self& __x) : current(__x.current) {}

#ifdef __VGTL_MEMBER_TEMPLATES

    template <class _Iter>
    pair_adaptor(const pair_adaptor<_Iter>& __x)
        : current(__x.base()) {}
#endif /* __VGTL_MEMBER_TEMPLATES */

    iterator_type base() const { return current; }

    reference operator*() const {
      _Iterator __tmp = current;
      return (*__tmp).second;
    }
#ifndef __SGI_STL_NO_ARROW_OPERATOR

    pointer operator->() const { return &(operator*()); }
#endif


    _Self& operator++() {
      ++current;
      return *this;
    }
    _Self operator++(int) {
      _Self __tmp = *this;
      ++current;
      return __tmp;
    }
    _Self& operator--() {
      --current;
      return *this;
    }
    _Self operator--(int) {
      _Self __tmp = *this;
      --current;
      return __tmp;
    }
       

    _Self operator+(difference_type __n) const {
      return _Self(current + __n);
    }

    _Self& operator+=(difference_type __n) {
      current += __n;
      return *this;
    }
    _Self operator-(difference_type __n) const {
      return _Self(current - __n);
    }
    _Self& operator-=(difference_type __n) {
      current -= __n;
      return *this;
    }
    reference operator[](difference_type __n) const { return *(*this + __n); }

    key_reference operator~() const {
      _Iterator __tmp = current;
      return (*__tmp).first;
    }
    
    _Self& operator=(const iterator_type& __x) {
      current = __x;
      return *this;
    }


    bool operator==(const iterator_type& __x) { return current == __x; }
    bool operator!=(const iterator_type& __x) { return current != __x; }
};


template <class _Tp>
class __one_iterator
{
  private:
    typedef __one_iterator<_Tp> _Self;
       
  public:

    typedef std::random_access_iterator_tag iterator_category;
    typedef ptrdiff_t difference_type;
    typedef _Tp value_type;
    typedef value_type* pointer;
    typedef value_type& reference;

  protected:
    pointer __value;
    bool __at;

  public:
    __one_iterator() : __value(NULL), __at(false) {}
    explicit __one_iterator(const value_type* __x)
        { __value = __x; __at = true; }

    __one_iterator(const _Self& __x) : __value(__x.__value), __at(__x.__at) {}
    __one_iterator(const pointer& __v, bool __a) : __value(__v), __at(__a) {}

    reference operator*() const {
      if(__at)
        return *__value;
      else
        return _Tp();
    }


    _Self& operator++() {
      if(__at) __at = false;
      return *this;
    }
    _Self operator++(int) {
      _Self __tmp = *this;
      if(__at) __at = false;
      return __tmp;
    }
    _Self& operator--() {
      if(!__at) __at = true;
      return *this;
    }
    _Self operator--(int) {
      _Self __tmp = *this;
      if(!__at) __at = true;
      return __tmp;
    }
       
    _Self operator+(difference_type __n) const {
      bool __h = __at;
      if(__h && __n != 0) __h = false;
      return _Self(__value, __h);
    }

    _Self& operator+=(difference_type __n) {
      if(__at && __n != 0) __at = false;
      return *this;
    }
    _Self operator-(difference_type __n) const {
      bool __h = __at;
      if(!__h && __n == 1) __h = true;
      return _Self(__value, __h);
    }
    _Self& operator-=(difference_type __n) {
      if(!__at && __n == 0) __at = true;
      return *this;
    }
    reference operator[](difference_type __n) const
      { if(__n == 0) return *__value;
        return NULL;
      }


    bool operator==(const _Self& __x)
        { return (__value == NULL && !__x.__at) ||
                 (__x.__value == NULL && !__at) ||
                 (__value == __x.__value && __at == __x.__at); }
    bool operator!=(const _Self& __x)
        { return (__value != NULL || __x.__at) &&
                 (__x.__value != NULL || __at) &&
                 (__value != __x.__value || __at != __x.__at); }
};


template <class Predicate, class _Node>
class _G_compare_adaptor : public std::binary_function<const void *, const void *, bool>
{
protected:
  Predicate pred;
  
  typedef _Node* node_ptr;
public:
  _G_compare_adaptor(const Predicate& __p) : pred(__p) {}

  bool operator() (const void *r, const void *l) const
  {
    return pred(((node_ptr) r)->_C_data, ((node_ptr) l)->_C_data);
  }
};

__VGTL_END_NAMESPACE

#endif /* __VGTL_INTADAPT_H_ */

---