index.h

Go to the documentation of this file.

// -*- C++ -*-

// CONTINUE: Consider giving all the classes a Functor suffix.

#if !defined(__ads_index_h__)
#define __ads_index_h__

#include "../defs.h"

#include <iterator>
#include <functional>

BEGIN_NAMESPACE_ADS

//-----------------------------------------------------------------------------
// @{

template <typename RAIter>
class IndexIteratorFunctor : 
  public std::binary_function<RAIter, 
                              int,
                              typename std::iterator_traits
                              <RAIter>::reference> {
private:
  typedef std::binary_function<RAIter, 
                               int,
                               typename std::iterator_traits
                               <RAIter>::reference> Base;

public:

  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;
  typedef typename Base::result_type result_type;

  result_type
  operator()(first_argument_type x, second_argument_type i) const {
    return x[i];
  }
};

template <typename RAIter> 
inline
IndexIteratorFunctor<RAIter>
index_iterator_functor() {
  return IndexIteratorFunctor<RAIter>();
}




template <typename RAIter>
class IndexIterUnary : 
  public std::unary_function<int,
                             typename std::iterator_traits
                             <RAIter>::reference> {
  //
  // Private types.
  //

private:

  typedef std::unary_function<int,
                              typename std::iterator_traits
                              <RAIter>::reference> Base;

  //
  // Public types.
  //

public:

  typedef typename Base::argument_type argument_type;
  typedef typename Base::result_type result_type;
  typedef RAIter iterator;

  //
  // Data.
  //

private:

  iterator _i;

  //
  // Not implemented.
  //

private:

  IndexIterUnary();  


  //
  // Constructors.
  //

public:

  IndexIterUnary(iterator i) :
    _i(i)
  {}
 
  //
  // Functor call.
  //

  result_type
  operator()(argument_type n) const {
    return _i[n];
  }
};

template <typename RAIter> 
inline
IndexIterUnary<RAIter>
index_iter_unary(RAIter i) {
  return IndexIterUnary<RAIter>(i);
}




template <typename Object>
class IndexObject : 
  public std::binary_function<Object, int, typename Object::reference> {
private:
  typedef std::binary_function<Object, int, typename Object::reference> 
  Base;

public:

  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;
  typedef typename Base::result_type result_type;

  result_type
  operator()(first_argument_type& x, second_argument_type i) const {
    return x[i];
  }
};

template <typename Object>
class IndexConstObject : 
  public std::binary_function<Object, int, typename Object::parameter_type> {
private:
  typedef std::binary_function<Object, int, typename Object::parameter_type>
  Base;

public:

  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;
  typedef typename Base::result_type result_type;

  result_type
  operator()(const first_argument_type& x, second_argument_type i) const {
    return x[i];
  }
};

template <typename Object>
inline
IndexObject<Object>
index_object() {
  return IndexObject<Object>();
}

template <typename Object>
inline
IndexConstObject<Object>
index_const_object() {
  return IndexConstObject<Object>();
}

// @}

END_NAMESPACE_ADS

#endif

---