compare_handle.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_compare_handle_h__)
#define __ads_compare_handle_h__

#include "../defs.h"

#include <functional>

BEGIN_NAMESPACE_ADS

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

template<typename Handle>
struct EqualToByHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return *x == *y; 
  }
};


template<typename Handle>
inline
EqualToByHandle<Handle>
constructEqualToByHandle() {
  return EqualToByHandle<Handle>();
}


template<typename Handle>
struct NotEqualToByHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return *x != *y;
  }
};


template<typename Handle>
inline
NotEqualToByHandle<Handle>
constructNotEqualToByHandle() {
  return NotEqualToByHandle<Handle>();
}


template<typename Handle>
struct GreaterByHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return *x > *y;
  }
};


template<typename Handle>
inline
GreaterByHandle<Handle>
constructGreaterByHandle() {
  return GreaterByHandle<Handle>();
}


template<typename Handle>
struct LessByHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return *x < *y; 
  }
};


template<typename Handle>
inline
LessByHandle<Handle>
constructLessByHandle() {
  return LessByHandle<Handle>();
}


template<typename Handle>
struct GreaterEqualByHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return *x >= *y; 
  }
};


template<typename Handle>
inline
GreaterEqualByHandle<Handle>
constructGreaterEqualByHandle() {
  return GreaterEqualByHandle<Handle>();
}


template<typename Handle>
struct LessEqualByHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return *x <= *y; 
  }
};


template<typename Handle>
inline
LessEqualByHandle<Handle>
constructLessEqualByHandle() {
  return LessEqualByHandle<Handle>();
}


//
// Handle-Handle
//


template<typename Handle>
struct EqualToByHandleHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return **x == **y; 
  }
};


template<typename Handle>
inline
EqualToByHandleHandle<Handle>
constructEqualToByHandleHandle() {
  return EqualToByHandleHandle<Handle>();
}


template<typename Handle>
struct NotEqualToByHandleHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return **x != **y;
  }
};


template<typename Handle>
inline
NotEqualToByHandleHandle<Handle>
constructNotEqualToByHandleHandle() {
  return NotEqualToByHandleHandle<Handle>();
}


template<typename Handle>
struct GreaterByHandleHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return **x > **y;
  }
};


template<typename Handle>
inline
GreaterByHandleHandle<Handle>
constructGreaterByHandleHandle() {
  return GreaterByHandleHandle<Handle>();
}


template<typename Handle>
struct LessByHandleHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return **x < **y; 
  }
};


template<typename Handle>
inline
LessByHandleHandle<Handle>
constructLessByHandleHandle() {
  return LessByHandleHandle<Handle>();
}


template<typename Handle>
struct GreaterEqualByHandleHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return **x >= **y; 
  }
};


template<typename Handle>
inline
GreaterEqualByHandleHandle<Handle>
constructGreaterEqualByHandleHandle() {
  return GreaterEqualByHandleHandle<Handle>();
}


template<typename Handle>
struct LessEqualByHandleHandle : 
  public std::binary_function<Handle,Handle,bool> {
private:
  typedef std::binary_function<Handle,Handle,bool> Base;
public:
  typedef typename Base::result_type result_type;
  typedef typename Base::first_argument_type first_argument_type;
  typedef typename Base::second_argument_type second_argument_type;

  result_type
  operator()(const first_argument_type x, const second_argument_type y) const { 
    return **x <= **y; 
  }
};


template<typename Handle>
inline
LessEqualByHandleHandle<Handle>
constructLessEqualByHandleHandle() {
  return LessEqualByHandleHandle<Handle>();
}

// @}

END_NAMESPACE_ADS

#endif

---