Loading...
Searching...
No Matches
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 - END
#ifndef CASACORE_NO_AUTO_TEMPLATES
#include <casacore/casa/Utilities/Compare.tcc>
#endif //# CASACORE_NO_AUTO_TEMPLATES
#endif
casacore::BaseCompare
abstract base class for comparing two objects
Definition Compare.h:63
casacore::BaseCompare::comp
virtual int comp(const void *obj1, const void *obj2) const =0
Compare two objects, and return.
casacore::BaseCompare::dataType
virtual DataType dataType() const
Get the data type of a straight-forward sort comparison in ObjCompare.
Definition Compare.h:79
casacore::BaseCompare::~BaseCompare
virtual ~BaseCompare()
Definition Compare.h:65
casacore::CompareAlwaysTrue
Comparison class that is always true.
Definition Compare.h:205
casacore::CompareAlwaysTrue::comp
virtual int comp(const void *obj1, const void *obj2) const
Comparison function that gives always true.
casacore::CompareAlwaysTrue::~CompareAlwaysTrue
virtual ~CompareAlwaysTrue()
casacore::CompareIntervalInt::itsInterval
Int64 itsInterval
Definition Compare.h:146
casacore::CompareIntervalInt::CompareIntervalInt
CompareIntervalInt(Int64 interval, Int64 start)
Construct from the given interval values.
casacore::CompareIntervalInt::itsStart
Int64 itsStart
Definition Compare.h:147
casacore::CompareIntervalInt::~CompareIntervalInt
virtual ~CompareIntervalInt()
casacore::CompareIntervalInt::comp
virtual int comp(const void *obj1, const void *obj2) const
Compare the interval the left and right value belong to.
casacore::CompareIntervalReal::itsStart
Double itsStart
Definition Compare.h:177
casacore::CompareIntervalReal::comp
virtual int comp(const void *obj1, const void *obj2) const
Compare the interval the left and right value belong to.
casacore::CompareIntervalReal::itsInterval
Double itsInterval
Definition Compare.h:176
casacore::CompareIntervalReal::CompareIntervalReal
CompareIntervalReal(Double interval, Double start)
Construct from the given interval values.
casacore::CompareIntervalReal::~CompareIntervalReal
virtual ~CompareIntervalReal()
casacore::CompareNoCase
Case-insensitive string comparison class.
Definition Compare.h:190
casacore::CompareNoCase::comp
virtual int comp(const void *obj1, const void *obj2) const
Compare the left and right string value in a case-insensitive way.
casacore::CompareNoCase::~CompareNoCase
virtual ~CompareNoCase()
casacore::ObjCompare
compare two objects
Definition Compare.h:99
casacore::ObjCompare::comp
virtual int comp(const void *obj1, const void *obj2) const
Compare two objects, and return.
casacore::ObjCompare::dataType
virtual DataType dataType() const
Get the data type of the sort comparison.
casacore::ObjCompare::compare
static int compare(const void *obj1, const void *obj2)
Compare two objects, and return.
casacore::ObjCompare::~ObjCompare
virtual ~ObjCompare()
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::Int64
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size).
Definition aipsxtype.h:36
casacore::Double
double Double
Definition aipstype.h:53
casacore::Compare_global_functions_ObjCompareFunc
Definition Compare.h:48
casacore::Compare_global_functions_ObjCompareFunc::ObjCompareFunc
int ObjCompareFunc(const void *, const void *)
Definition Compare.h:49