composite_compare.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__ads_composite_compare_h__)
#define __ads_composite_compare_h__

// If we are debugging the whole ads package.
#if defined(DEBUG_ads) && !defined(DEBUG_composite_compare)
#define DEBUG_composite_compare
#endif

#include "../array/FixedArray.h"

#include <functional>

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

//
// Comparisons for N-D numbers.
//

template <int N, typename PointType>
bool 
less_composite_fcn( const int n, const PointType& a,  const PointType& b );
/* Defined in the .ipp file. */


/* CONTINUE
template <int N, typename T>
bool 
less_composite_fcn( int i, const FixedArray<N,T>* a, 
                    const FixedArray<N,T>* b );
*/

template <int N, typename PointType>
class less_composite :
  public std::binary_function<PointType, PointType, bool>
{
private:

  int _n;

public:

  less_composite() :
    _n( -1 )
  {}

  void
  set( const int n )
  {
    _n = n;
  }

  bool 
  operator()( const PointType& a, const PointType& b ) const
  {
    return less_composite_fcn<N>( _n, a, b );
  }
};

/* CONTINUE: I don't know if I need this.
template <class PointType>
class less_composite<PointType*> :
  public std::binary_function<const PointType*, const PointType*, bool>
{
private:

  int _n;

public:

  void
  set( int n )
  {
    _n = n;
  }

  bool 
  operator()( const PointType* a, const PointType* b ) 
  {
    return less_composite_fcn( _n, *a, *b );
  }
};
*/

//
// Comparisons for 3-D numbers.
//

template <typename Pt3D>
bool 
xless_composite_compare( const Pt3D& a, const Pt3D& b );

template <typename Pt3D>
bool 
yless_composite_compare( const Pt3D& a, const Pt3D& b );

template <typename Pt3D>
bool 
zless_composite_compare( const Pt3D& a, const Pt3D& b );

template <typename Pt3D>
bool 
less_composite_compare( int i, const Pt3D& a, const Pt3D& b );

template <class PointType>
struct xless_composite :
  public std::binary_function<PointType, PointType, bool>
{
  bool 
  operator()( const PointType& a, const PointType& b ) {
    return xless_composite_compare( a, b );
  }
};

template <class PointType>
struct yless_composite :
  public std::binary_function<PointType, PointType, bool>
{
  bool 
  operator()( const PointType& a, const PointType& b ) {
    return yless_composite_compare( a, b );
  }
};

template <class PointType>
struct zless_composite :
  public std::binary_function<PointType, PointType, bool>
{
  bool 
  operator()( const PointType& a, const PointType& b ) {
    return zless_composite_compare( a, b );
  }
};



// CONTINUE
//--------------------------------------------------------------------------
#if 0
template <typename T>
bool 
xless_composite_compare( const FixedArray<3,T>& a, 
                         const FixedArray<3,T>& b );

template <typename T>
bool 
yless_composite_compare( const FixedArray<3,T>& a, 
                         const FixedArray<3,T>& b );

template <typename T>
bool 
zless_composite_compare( const FixedArray<3,T>& a, 
                         const FixedArray<3,T>& b );


template <typename T>
bool 
xless_composite_compare( const FixedArray<3,T>* a, 
                         const FixedArray<3,T>* b );

template <typename T>
bool 
yless_composite_compare( const FixedArray<3,T>* a, 
                         const FixedArray<3,T>* b );

template <typename T>
bool 
zless_composite_compare( const FixedArray<3,T>* a, 
                         const FixedArray<3,T>* b );
  
template <typename T>
bool 
less_composite_compare( int i, const FixedArray<3,T>& a, 
                        const FixedArray<3,T>& b );

template <typename T>
bool 
less_composite_compare( int i, const FixedArray<3,T>* a, 
                        const FixedArray<3,T>* b );


template <class PointType>
struct xless_composite :
  public std::binary_function<PointType, PointType, bool>
{
  bool operator()( const PointType& a, const PointType& b ) {
    return xless_composite_compare( a, b );
  }
};

template <class PointType>
struct xless_composite<PointType*> :
  public std::binary_function<const PointType*, 
                              const PointType*, bool>
{
  bool operator()( const PointType* a, const PointType* b ) {
    return xless_composite_compare( a, b );
  }
};


template <class PointType>
struct yless_composite :
  public std::binary_function<PointType, PointType, bool>
{
  bool operator()( const PointType& a, const PointType& b ) {
    return yless_composite_compare( a, b );
  }
};

template <class PointType>
struct yless_composite<PointType*> :
  public std::binary_function<const PointType*, const PointType*, bool>
{
  bool operator()( const PointType* a, const PointType* b ) {
    return yless_composite_compare( a, b );
  }
};


template <class PointType>
struct zless_composite :
  public std::binary_function<PointType, PointType, bool>
{
  bool operator()( const PointType& a, const PointType& b ) {
    return zless_composite_compare( a, b );
  }
};

  
template <class PointType>
struct zless_composite<PointType*> :
  public std::binary_function<const PointType*, 
                              const PointType*, bool>
{
  bool operator()( const PointType* a, const PointType* b ) {
    return zless_composite_compare( a, b );
  }
};
//--------------------------------------------------------------------------
#endif

// @}

END_NAMESPACE_ADS

#define __ads_composite_compare_ipp__
#include "composite_compare.ipp"
#undef __ads_composite_compare_ipp__

#endif

---