Compare.h

Go to the documentation of this file.

// # Compare.h: compare two objects of the same type
// # Copyright (C) 1994,1995,1999
// # Associated Universities, Inc. Washington DC, USA.
// #
// # This library is free software; you can redistribute it and/or modify it
// # under the terms of the GNU Library General Public License as published by
// # the Free Software Foundation; either version 2 of the License, or (at your
// # option) any later version.
// #
// # This library is distributed in the hope that it will be useful, but WITHOUT
// # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
// # License for more details.
// #
// # You should have received a copy of the GNU Library General Public License
// # along with this library; if not, write to the Free Software Foundation,
// # Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
// #
// # Correspondence concerning AIPS++ should be addressed as follows:
// #        Internet email: casa-feedback@nrao.edu.
// #        Postal address: AIPS++ Project Office
// #                        National Radio Astronomy Observatory
// #                        520 Edgemont Road
// #                        Charlottesville, VA 22903-2475 USA
 
#ifndef CASA_COMPARE_H
#define CASA_COMPARE_H
 
// # Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/Utilities/DataType.h>
 
namespace casacore {  // # NAMESPACE CASACORE - BEGIN
 
// <summary> signature of comparison functions </summary>
// <use visibility=export>
// <reviewed reviewer="Friso Olnon" date="1995/02/24" tests="" demos="">
 
// <synopsis>
// This typedef defines the signature of the comparison functions used
// in, for instance, the <linkto class="Sort">Sort</linkto> class: functions
// with two <src>const void*</src> arguments returning an
// <src>int</src> value. One such function is defined in the
// <linkto class="ObjCompare">ObjCompare</linkto> class.
// </synopsis>
 
// <group name=ObjCompareFunc>
typedef int ObjCompareFunc(const void*, const void*);
// </group>
 
// <summary> abstract base class for comparing two objects </summary>
// <use visibility=export>
// <reviewed reviewer="Friso Olnon" date="1995/02/24" tests="" demos="">
//
// <synopsis>
// The abstract class <src>BaseCompare<T></src> is used for comparisons
// in sorting or iterating. One can derive a concrete comparison class
// from it.
// </synopsis>
 
class BaseCompare {
 public:
  virtual ~BaseCompare() {}
 
  // Compare two objects, and return.
  // <ul>
  //  <li> -1  if obj1 < obj2;
  //  <li>  0  if obj1 == obj2;
  //  <li>  1  otherwise.
  // </ul>
  virtual int comp(const void* obj1, const void* obj2) const = 0;
 
  // Get the data type of a straight-forward sort comparison in ObjCompare.
  // It is used to test if a the faster GenSortIndirect can be used.
  // By default it returns TpOther.
  virtual DataType dataType() const { return TpOther; }
};
 
// <summary> compare two objects </summary>
// <use visibility=export>
// <reviewed reviewer="Friso Olnon" date="1995/02/24" tests="" demos="">
 
// <synopsis>
// The templated class <src>ObjCompare<T></src> really is only a place
// holder for the static function <src>compare</src> which compares two
// objects of type T.
// </synopsis>
 
// <templating arg=T>
// <li> operator==
// <li> operator<
// </templating>
 
template <class T>
class ObjCompare : public BaseCompare {
 public:
  virtual ~ObjCompare();
 
  // Compare two objects, and return
  // <ul>
  //  <li> -1  if obj1 < obj2;
  //  <li>  0  if obj1 == obj2;
  //  <li>  1  otherwise.
  // </ul>
  // The static function is not inlined allowing one to take the address of
  // it. Furthermore, the function's signature agrees with
  // <linkto group="Compare.h#ObjCompareFunc">ObjCompareFunc</linkto>.
  static int compare(const void* obj1, const void* obj2);
  virtual int comp(const void* obj1, const void* obj2) const;
 
  // Get the data type of the sort comparison.
  virtual DataType dataType() const;
};
 
// <summary>Integer comparison class with intervals</summary>
// <use visibility=export>
// <reviewed reviewer="" date="" tests="tTableIter" demos="">
 
// <synopsis>
// This class is meant for comparison in the TableIterator class.
// It does not compare on the value itself, but compares intervals.
// In that way it is possible to iterate through a table in, for example,
// time chunks of N seconds. The start value X gives the start value of
// the base interval. Lower intervals are still possible.
// So the intervals will be ..., X-2N:X-N, X-N:N, X:X+N, X+N:X+2N, ...
// </synopsis>
template <typename T>
class CompareIntervalInt : public BaseCompare {
 public:
  // Construct from the given interval values.
  CompareIntervalInt(Int64 interval, Int64 start);
 
  virtual ~CompareIntervalInt();
 
  // Compare the interval the left and right value belong to.
  virtual int comp(const void* obj1, const void* obj2) const;
 
 private:
  Int64 itsInterval;
  Int64 itsStart;
};
 
// <summary>Real comparison class with intervals</summary>
// <use visibility=export>
// <reviewed reviewer="" date="" tests="tTableIter" demos="">
 
// <synopsis>
// This class is meant for comparison in the TableIterator class.
// It does not compare on the value itself, but compares intervals.
// In that way it is possible to iterate through a table in, for example,
// time chunks of N seconds. The start value X gives the start value of
// the base interval. Lower intervals are still possible.
// So the intervals will be ..., X-2N:X-N, X-N:N, X:X+N, X+N:X+2N, ...
// </synopsis>
template <typename T>
class CompareIntervalReal : public BaseCompare {
 public:
  // Construct from the given interval values.
  CompareIntervalReal(Double interval, Double start);
 
  virtual ~CompareIntervalReal();
 
  // Compare the interval the left and right value belong to.
  virtual int comp(const void* obj1, const void* obj2) const;
 
 private:
  Double itsInterval;
  Double itsStart;
};
 
// <summary>Case-insensitive string comparison class </summary>
// <use visibility=export>
// <reviewed reviewer="" date="" tests="tTableIter" demos="">
 
// <synopsis>
// This class is meant for an case-insensitive comparison in a sort
// or table iteration.
// </synopsis>
class CompareNoCase : public BaseCompare {
 public:
  virtual ~CompareNoCase();
 
  // Compare the left and right string value in a case-insensitive way.
  virtual int comp(const void* obj1, const void* obj2) const;
};
 
// <summary>Comparison class that is always true</summary>
 
// <synopsis>
// This class is meant to always give true and can be used to ensure
// that all the values of a given column are grouped together.
// </synopsis>
class CompareAlwaysTrue : public BaseCompare {
 public:
  virtual ~CompareAlwaysTrue();
 
  // Comparison function that gives always true
  virtual int comp(const void* obj1, const void* obj2) const;
};
 
}  // namespace casacore
 
#ifndef CASACORE_NO_AUTO_TEMPLATES
#include <casacore/casa/Utilities/Compare.tcc>
#endif  // # CASACORE_NO_AUTO_TEMPLATES
#endif