TrivialOutputIterator.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_TrivialOutputIterator_h__)
#define __ads_TrivialOutputIterator_h__

#include "../defs.h"

#include <iterator>

BEGIN_NAMESPACE_ADS


class TrivialOutputIterator : 
  public std::iterator<std::output_iterator_tag,void,void,void,void> {
private:

  //
  // Private types.
  //

  typedef std::iterator<std::output_iterator_tag,void,void,void,void> 
  Base;

public:

  //
  // Public types.
  //

  // The following five types are required to be defined for any iterator.

  typedef Base::iterator_category iterator_category;
  typedef Base::value_type value_type;
  typedef Base::difference_type difference_type;
  typedef Base::pointer pointer;
  typedef Base::reference reference;
  
  //--------------------------------------------------------------------------


  TrivialOutputIterator() 
  {}

  TrivialOutputIterator(const TrivialOutputIterator&) 
  {}

  TrivialOutputIterator& 
  operator=(const TrivialOutputIterator&) {
    return *this;
  }

  //--------------------------------------------------------------------------


  template<typename Value>
  TrivialOutputIterator&
  operator=(const Value&) {
    return *this;
  }
  
  TrivialOutputIterator&
  operator*() {
    return *this;
  }

  TrivialOutputIterator&
  operator++() {
    return *this;
  }

  TrivialOutputIterator
  operator++(int) {
    return *this;
  }


};


inline
TrivialOutputIterator
constructTrivialOutputIterator() {
  TrivialOutputIterator x;
  return x;
}



class TrivialOutputIteratorCount : 
  public TrivialOutputIterator {
  //
  // Private types.
  //
private:

  typedef TrivialOutputIterator Base;

  //
  // Public types.
  //
public:

  // The following five types are required to be defined for any iterator.

  typedef Base::iterator_category iterator_category;
  typedef Base::value_type value_type;
  typedef Base::difference_type difference_type;
  typedef Base::pointer pointer;
  typedef Base::reference reference;

  //
  // Member data.
  //
private:

  int& _count;
  
  //
  // Not implemented.
  //
private:

  // Default constructor not implemented.
  TrivialOutputIteratorCount();
  // Assignment operator not implemented.
  TrivialOutputIteratorCount& 
  operator=(const TrivialOutputIteratorCount&);

  //--------------------------------------------------------------------------

public:

  TrivialOutputIteratorCount(int& count) :
    _count(count) {
  }

  TrivialOutputIteratorCount(const TrivialOutputIteratorCount& other) :
    _count(other._count) {
  }

  //--------------------------------------------------------------------------

public:

  template<typename Value>
  TrivialOutputIteratorCount&
  operator=(const Value&) {
    ++_count;
    return *this;
  }

  int
  get() const {
    return _count;
  }

  void
  reset() {
    _count = 0;
  }
  
  TrivialOutputIteratorCount&
  operator*() {
    return *this;
  }

  TrivialOutputIteratorCount&
  operator++() {
    return *this;
  }


  TrivialOutputIteratorCount&
  operator++(int) {
    return *this;
  }


};


inline
TrivialOutputIteratorCount
constructTrivialOutputIteratorCount(int& count) {
  TrivialOutputIteratorCount x(count);
  return x;
}


END_NAMESPACE_ADS

#endif

---