//# 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: aips2-request@nrao.edu. //# Postal address: AIPS++ Project Office //# National Radio Astronomy Observatory //# 520 Edgemont Road //# Charlottesville, VA 22903-2475 USA //# //# $Id$ #ifndef CASA_COMPARE_H #define CASA_COMPARE_H //# Includes #include #include namespace casacore { //# NAMESPACE CASACORE - BEGIN // signature of comparison functions // // // // This typedef defines the signature of the comparison functions used // in, for instance, the Sort class: functions // with two const void* arguments returning an // int value. One such function is defined in the // ObjCompare class. // // typedef int ObjCompareFunc (const void*, const void*); // // abstract base class for comparing two objects // // // // // The abstract class BaseCompare is used for comparisons // in sorting or iterating. One can derive a concrete comparison class // from it. // class BaseCompare { public: virtual ~BaseCompare() {} // Compare two objects, and return. //
    //
  • -1 if obj1 < obj2; //
  • 0 if obj1 == obj2; //
  • 1 otherwise. //
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; } }; // compare two objects // // // // The templated class ObjCompare really is only a place // holder for the static function compare which compares two // objects of type T. // // //
  • operator== //
  • operator< // template class ObjCompare: public BaseCompare { public: virtual ~ObjCompare(); // Compare two objects, and return //
      //
    • -1 if obj1 < obj2; //
    • 0 if obj1 == obj2; //
    • 1 otherwise. //
    // The static function is not inlined allowing one to take the address of // it. Furthermore, the function's signature agrees with // ObjCompareFunc. 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; }; // Integer comparison class with intervals // // // // 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, ... // template 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; }; // Real comparison class with intervals // // // // 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, ... // template 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; }; // Case-insensitive string comparison class // // // // This class is meant for an case-insensitive comparison in a sort // or table iteration. // 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; }; // Comparison class that is always true // // 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. // 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 #endif //# CASACORE_NO_AUTO_TEMPLATES #endif