vcl_iterator.h

来自「DTMK软件开发包,此为开源软件,是一款很好的医学图像开发资源.」· C头文件 代码 · 共 569 行 · 第 1/2 页

//
// Copyright (c) 1994
// Hewlett-Packard Company
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Hewlett-Packard Company makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
//
// Copyright (c) 1996
// Silicon Graphics Computer Systems, Inc.
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Silicon Graphics makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
// Copyright (c) 1997
// Moscow Center for SPARC Technology
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Moscow Center for SPARC Technology makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//

#ifndef vcl_emulation_iterator_h
#define vcl_emulation_iterator_h

#include <vcl_cstddef.h>
#include <vcl_iostream.h>
#include "vcl_functional.h"

#if defined ( __STL_USE_ABBREVS )
// ugliness is intentional - to reduce conflicts
# define vcl_input_iterator_tag             InItT
# define vcl_output_iterator_tag            OuItT
# define vcl_bidirectional_iterator_tag     BdItT
# define vcl_random_access_iterator_tag     RaItT
# define vcl_forward_iterator               FwIt
# define vcl_input_iterator                 InIt
# define vcl_output_iterator                OuIt
# define vcl_bidirectional_iterator         BdIt
# define vcl_random_access_iterator         RaIt
# define vcl_reverse_bidirectional_iterator rBdIt
# define vcl_reverse_iterator               rIt
# define vcl_back_insert_iterator           bIIt
# define vcl_front_insert_iterator          fIIt
# define vcl_raw_storage_iterator           rSIt
# define vcl_istream_iterator               iSIt
# define vcl_ostream_iterator               oSIt
#endif

struct vcl_input_iterator_tag {};
struct vcl_output_iterator_tag { vcl_output_iterator_tag() {} };
struct vcl_forward_iterator_tag {};
struct vcl_bidirectional_iterator_tag { vcl_bidirectional_iterator_tag() {} };
struct vcl_random_access_iterator_tag {};

template <class T, class Distance> struct vcl_input_iterator {};
struct vcl_output_iterator {};
template <class T, class Distance> struct vcl_forward_iterator {};
template <class T, class Distance> struct vcl_bidirectional_iterator {};
template <class T, class Distance> struct vcl_random_access_iterator {};

template <class T, class Distance>
inline vcl_input_iterator_tag
iterator_category(const vcl_input_iterator<T, Distance>&) {
    return vcl_input_iterator_tag();
}

inline vcl_output_iterator_tag
iterator_category(const vcl_output_iterator&) {
    return vcl_output_iterator_tag();
}

template <class T, class Distance>
inline vcl_forward_iterator_tag
iterator_category(const vcl_forward_iterator<T, Distance>&) {
    return vcl_forward_iterator_tag();
}

template <class T, class Distance>
inline vcl_bidirectional_iterator_tag
iterator_category(const vcl_bidirectional_iterator<T, Distance>&) {
    return vcl_bidirectional_iterator_tag();
}

template <class T, class Distance>
inline vcl_random_access_iterator_tag
iterator_category(const vcl_random_access_iterator<T, Distance>&) {
    return vcl_random_access_iterator_tag();
}

template <class T>
inline vcl_random_access_iterator_tag
iterator_category(const T*) {
    return vcl_random_access_iterator_tag();
}

template <class T, class Distance>
inline T*
value_type(const vcl_input_iterator<T, Distance>&) {
    return (T*)(0);
}

template <class T, class Distance>
inline T*
value_type(const vcl_forward_iterator<T, Distance>&) {
    return (T*)(0);
}

template <class T, class Distance>
inline T*
value_type(const vcl_bidirectional_iterator<T, Distance>&) {
    return (T*)(0);
}

template <class T, class Distance>
inline T*
value_type(const vcl_random_access_iterator<T, Distance>&) {
    return (T*)(0);
}

template <class T>
inline T*
value_type(const T*) { return (T*)(0); }

template <class T, class Distance>
inline Distance*
distance_type(const vcl_input_iterator<T, Distance>&) {
    return (Distance*)(0);
}

template <class T, class Distance>
inline Distance*
distance_type(const vcl_forward_iterator<T, Distance>&) {
    return (Distance*)(0);
}

template <class T, class Distance>
inline Distance*
distance_type(const vcl_bidirectional_iterator<T, Distance>&) {
    return (Distance*)(0);
}

template <class T, class Distance>
inline Distance*
distance_type(const vcl_random_access_iterator<T, Distance>&) {
    return (Distance*)(0);
}

template <class T>
inline vcl_ptrdiff_t*
distance_type(const T*) { return (vcl_ptrdiff_t*)(0); }

template <class Container>
class vcl_back_insert_iterator {
protected:
    typedef typename Container::value_type value_type;
    Container* container;
public:
    vcl_back_insert_iterator(Container& x) : container(&x) {}
    vcl_back_insert_iterator<Container>&
    operator=(const value_type& value) {
        container->push_back(value);
        return *this;
    }
    vcl_back_insert_iterator<Container>& operator*() { return *this; }
    vcl_back_insert_iterator<Container>& operator++() { return *this; }
    vcl_back_insert_iterator<Container>& operator++(int) { return *this; }
};

template <class Container>
inline vcl_output_iterator_tag
iterator_category(const vcl_back_insert_iterator<Container>&)
{
    return vcl_output_iterator_tag();
}

template <class Container>
inline vcl_back_insert_iterator<Container>
vcl_back_inserter(Container& x)  {
    return vcl_back_insert_iterator<Container>(x);
}

template <class Container>
class vcl_front_insert_iterator {
protected:
    Container* container;
public:
    vcl_front_insert_iterator(Container& x) : container(&x) {}
    vcl_front_insert_iterator<Container>&
    operator=(const typename Container::value_type& value) {
        container->push_front(value);
        return *this;
    }
    vcl_front_insert_iterator<Container>& operator*() { return *this; }
    vcl_front_insert_iterator<Container>& operator++() { return *this; }
    vcl_front_insert_iterator<Container>& operator++(int) { return *this; }
};

template <class Container>
inline vcl_output_iterator_tag
iterator_category(const vcl_front_insert_iterator<Container>&)
{
    return vcl_output_iterator_tag();
}

template <class Container>
inline vcl_front_insert_iterator<Container>
front_inserter(Container& x)  {
    return vcl_front_insert_iterator<Container>(x);
}

template <class Container>
class vcl_insert_iterator {
protected:
    Container* container;
    typename Container::iterator iter;
public:
    vcl_insert_iterator(Container& x, typename Container::iterator i)
        : container(&x), iter(i) {}
    vcl_insert_iterator<Container>&
    operator=(const typename Container::value_type& value) {
        iter = container->insert(iter, value);
        ++iter;
        return *this;
    }
    vcl_insert_iterator<Container>& operator*() { return *this; }
    vcl_insert_iterator<Container>& operator++() { return *this; }
    vcl_insert_iterator<Container>& operator++(int) { return *this; }
};

template <class Container>
inline vcl_output_iterator_tag
iterator_category(const vcl_insert_iterator<Container>&)
{
    return vcl_output_iterator_tag();
}

template <class Container, class Iterator>
inline vcl_insert_iterator<Container> vcl_inserter(Container& x, Iterator i) {
  typedef typename Container::iterator iter;
  return vcl_insert_iterator<Container>(x, iter(i));
}

// Forward declarations
template <class BidirectionalIterator, class T, class Reference, class Distance> class vcl_reverse_bidirectional_iterator;
template <class BidirectionalIterator, class T, class Reference, class Distance> inline bool operator==
   (
    const vcl_reverse_bidirectional_iterator<BidirectionalIterator, T, Reference, Distance>& x,
    const vcl_reverse_bidirectional_iterator<BidirectionalIterator, T, Reference, Distance>& y);

template <class BidirectionalIterator, class T,
          VCL_DFL_TMPL_PARAM_STLDECL(Reference, T& ),
          VCL_DFL_TYPE_PARAM_STLDECL(Distance, vcl_ptrdiff_t)>
class vcl_reverse_bidirectional_iterator {
    typedef vcl_reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
                                               Distance> self;
    friend bool operator== VCL_NULL_TMPL_ARGS (const self& x, const self& y);
protected:
    BidirectionalIterator current;
public:
    vcl_reverse_bidirectional_iterator() {}
    vcl_reverse_bidirectional_iterator(const BidirectionalIterator&x): current(x) {}
    BidirectionalIterator base() { return current; }
    Reference operator*() const {
        BidirectionalIterator tmp = current;
        return *--tmp;
    }
    self& operator++() {
        --current;
        return *this;
    }