AttValTol.h

Go to the documentation of this file.

//# AttValTol.h: templated class for tolerant AttributeValues
//# Copyright (C) 1996,1997,1999,2000,2001
//# 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 TRIALDISPLAY_ATTVALTOL_H
#define TRIALDISPLAY_ATTVALTOL_H

#include <casa/aips.h>
#include <display/Display/AttVal.h>

namespace casa { //# NAMESPACE CASA - BEGIN

        class AttValBase;

// <summary>
// Templated class for storing Attributes which have a tolerance.
// </summary>

// <use visibility=export>

// <reviewed reviewer="" date="yyyy/mm/dd" tests="tAttribute" demos="">
// </reviewed>

// <prerequisite>
// <li> <linkto class="AttributeValue">AttributeValue</linkto>
// </prerequisite>

// <etymology>
// "AttributeValueTol" is a contraction of "Attribute Value" and
// "Tolerance", and stores an Attribute which has associated with
// it some tolerance to be observed in matching with other
// Attributes.
// </etymology>

// <synopsis>
// An AttributeValueTol differs from a <linkto class="AttributeValue">
// AttributeValue</linkto> in that it has associated with it a certain
// tolerance, which will be observed when matching the value with
// other AttributeValues.  This means that values do not have to match
// exactly in order for the AttributeValueTols to match.  Tolerant
// matching is defined as <src>abs(val1-val2) <= tolerance1</src>.
// Remember though that in general both Attributes must independently
// match each other for a match to exist, and so it is normally also a
// requirement that <src>abs(val1 - val2) <= tolerance2</src> when the
// second Attribute also has tolerance specified.
// </synopsis>

// <example>
// If we have
//
// <srcBlock>
// AttributeValueTol<Float> Att1(3.0, 1.2, False);
// AttributeValueTol<Float> Att2(2.0, 1.1, False);
// AttributeValueTol<Float> Att3(2.1, 0.5, False);
// </srcBlock>
//
// then:
// <li> <src>Att1==Att2</src> returns <src>True</src>,
// <li> <src>Att2==Att3</src> returns <src>True</src>,
// <li> but <src>Att3==Att1</src> returns <src>False</src>.
// </example>
//
// <motivation>
// The motivation for this class is to be able to provide some
// in-built tolerance ("fuzziness") to AttributeValues.  For example,
// this approach might be used in selecting channel maps to display
// when matching on radial velocity.
// </motivation>
// <todo asof="2000/01/17">
// </todo>


        template <class T> class AttributeValueTol : public AttributeValue<T> {

        public:
                // Constructor for a scalar, with specified scalar tolerance and
                // strictness.
                AttributeValueTol(const T &value, const T &tolerance, const Bool strict);

                // Constructor for a <src>Vector</src> value, with specified scalar
                // tolerance and strictness.
                AttributeValueTol(const Vector<T> &value, const T &tolerance, const Bool strict);

                // Copy contructor.
                AttributeValueTol(const AttributeValueTol<T> &other);

                // Destructor.
                virtual ~AttributeValueTol();

                // Assignment operator.
                const AttributeValueTol<T> &operator=(const AttributeValueTol<T>& other);

                // Return a new copy of the AttributeValueTol (virtual constructor).
                virtual AttributeValueBase *clone() const;

                // Change or retrieve the scalar tolerance.
                // <group>
                virtual void setTolerance(T value) {
                        itsValueTolerance = value;
                };
                virtual T getTolerance() const {
                        return itsValueTolerance;
                };
                // </group>

                // Return class name
                virtual String className() const {
                        return String("AttributeValueTol");
                };

        protected:

                // Implements when the values of two Attributes match, taking note
                // of tolerance in this particular implementation.
                virtual Bool matches(const AttributeValueBase& other) const;

        private:

                // The value of the tolerance
                T itsValueTolerance;

                // Does the actual matching
                Bool myMatch(const AttributeValue<T>& other) const;

                // Default constructor
                AttributeValueTol();

                //# Make parent members known.
        public:
                using AttributeValue<T>::getType;
                using AttributeValue<T>::getValue;
                using AttributeValue<T>::getStrictness;
        };

} //# NAMESPACE CASA - END

#ifndef AIPS_NO_TEMPLATE_SRC
#include <display/Display/AttValTol.tcc>
#endif //# AIPS_NO_TEMPLATE_SRC

#endif