AttValBase.h

Go to the documentation of this file.

//# AttValBase.h: abstract base class and support class for AttributeValues
//# Copyright (C) 1996,1997,1999,2000,2001,2002
//# 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_ATTVALBASE_H
#define TRIALDISPLAY_ATTVALBASE_H

#include <casa/aips.h>
#include <casa/Utilities/DataType.h>
#include <casa/Arrays/Vector.h>
#include <casa/Quanta/Quantum.h>
#include <casa/iostream.h>

namespace casa { //# NAMESPACE CASA - BEGIN

// <summary>
// Provision of type identification services for Attribute classes.
// </summary>
//
// <use visibility=local>
//
// <reviewed reviewer="" date="yyyy/mm/dd" tests="tAttribute" demos="">
// </reviewed>
//
// <etymology>
// "AttValue" is a contraction of "Attribute Value"
// </etymology>
//
// <synopsis>
// AttValue provides type identification services for use in the
// Attribute classes.
// </synopsis>
//
// <example>
// AttValue can be used to provide an enumeration which identifies
// the type of a variable, for example:
// <srcblock>
// Int i;
// if (AttValue::whatType(&i) != AttValue::AtInt) {
//   throw(AipsError(String("Incorrect type identification in AttValue")));
// }
// </srcblock>
// </example>
//
// <motivation>
// This is a support class to unify type identification for the
// various Attribute classes.
// </motivation>
//
// <todo asof="2000/01/17">
// <li> Consider using global whatType function instead of this class.
// </todo>

        class AttValue {

        public:

                // The possible value types.
                enum ValueType {
                    AtuInt,
                    AtInt,
                    AtFloat,
                    AtDouble,
                    AtBool,
                    AtString,
                    AtQuantity,
                    AtInvalid
                };

                // Determine the type of a scalar or Array variable.
                // <group>
                static AttValue::ValueType whatType(uInt *) {
                        return AttValue::AtuInt;
                };
                static AttValue::ValueType whatType(Vector<uInt> *) {
                        return AttValue::AtuInt;
                };
                static AttValue::ValueType whatType(Int *) {
                        return AttValue::AtInt;
                };
                static AttValue::ValueType whatType(Vector<Int> *) {
                        return AttValue::AtInt;
                };
                static AttValue::ValueType whatType(Float *) {
                        return AttValue::AtFloat;
                };
                static AttValue::ValueType whatType(Vector<Float> *) {
                        return AttValue::AtFloat;
                };
                static AttValue::ValueType whatType(Double *) {
                        return AttValue::AtDouble;
                };
                static AttValue::ValueType whatType(Vector<Double> *) {
                        return AttValue::AtDouble;
                };
                static AttValue::ValueType whatType(Bool *) {
                        return AttValue::AtBool;
                };
                static AttValue::ValueType whatType(Vector<Bool> *) {
                        return AttValue::AtBool;
                };
                static AttValue::ValueType whatType(String *) {
                        return AttValue::AtString;
                };
                static AttValue::ValueType whatType(Vector<String> *) {
                        return AttValue::AtString;
                };
                static AttValue::ValueType whatType(Quantity *) {
                        return AttValue::AtQuantity;
                };
                static AttValue::ValueType whatType(Vector<Quantity> *) {
                        return AttValue::AtQuantity;
                };
                static AttValue::ValueType whatType(void *) {
                        return AttValue::AtInvalid;
                };
                // </group>

        };

// <summary>
// Base class for values of Attributes used in the display classes.
// </summary>
//
// <use visibility=export>
//
// <reviewed reviewer="" date="yyyy/mm/dd" tests="tAttribute" demos="">
// </reviewed>
//
// <etymology>
// "AttributeValueBase" is a concatenation, representing a "Base"
// class for "Attribute Values."
// </etymology>
//
// <synopsis>
// This class is the base for storing Attribute values.  <linkto
// class=Attribute> Attributes </linkto> are simple name-value pairs,
// where the name is a String, and the value can be a scalar or Array.
//
// This class defines the type-independent interface for Attribute
// values, and the type-dependent interface and implementation is
// provided in <linkto class=AttributeValue> AttributeValue </linkto>.
// This type independent interface allows comparison of Attributes
// of different types.
// </synopsis>
//
// <motivation>
// To provide the non-templated (ie. type-independent) interface of
// AttributeValues in a single place, thus enabling the hiding of
// the templated aspect of Attributes from the end-user.  In particular
// it allows implementation of the comparison operators in the base
// class, regardless of type.
// </motivation>
//
// <todo asof="1999/12/09">
// Nothing known.
// </todo>

        class AttributeValueBase  {

        public:

                // Constructor.
                AttributeValueBase(AttValue::ValueType type, Bool strict);

                // Copy constructor.
                AttributeValueBase(const AttributeValueBase &other);

                // Destructor.
                virtual ~AttributeValueBase();

                // Copy assignment.
                const AttributeValueBase& operator=(const AttributeValueBase &other);

                // Get the type of the value stored.
                AttValue::ValueType getType() const;

                // Check for equality (and inequality) of two objects derived from
                // AttributeValueBase.  It is implemented in terms of the pure
                // virtual method <src>matches</src>, which must be implemented in
                // derived classes.  The <src>operator==</src> only returns
                // <src>True</src> if <src>this->matches(other)</src> and
                // <src>other.matches(*this)</src> are both <src>True</src>.  This
                // guarantees that if <src> a == b </src> it follows that <src> b ==
                // a </src> (this is enforced this way because <src>a</src> and
                // <src>b</src> can be classes derived differently from
                // AttributeValueBase which can therefore have a different
                // implementation of <src>match()</src>).
                // <group>
                Bool operator==(const AttributeValueBase &other) const;
                Bool operator!=(const AttributeValueBase &other) const;
                // </group>

                // Return a new copy of the AttributeValueBase
                virtual AttributeValueBase* clone() const = 0;

                // Set/get the strictness state of this AttributeValue.
                // <group>
                virtual void setStrictness(const Bool &newStrict);
                virtual Bool getStrictness() const;
                // </group>

                // Add <src>other</src> to <src>*this</src>.
                virtual void operator+=(const AttributeValueBase& other) = 0;

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

                virtual void print(ostream& os) = 0;

        protected:

                // The type of what is stored.
                AttValue::ValueType itsValueType;

                // Whether the match is strict or not.
                Bool itsStrictness;

                // Calculate whether <src>*this</src> matches <src>other</src>.
                // Since the meaning of "match" can be different for different
                // types, it is left to the derived class to define this method.
                virtual Bool matches(const AttributeValueBase &other) const = 0;

                // Set the type of the value stored.
                virtual void setType(const AttValue::ValueType &newType);

                // Check that private data match
                Bool myMatch(const AttributeValueBase &other) const;
        };

        ostream &operator<<(ostream &os, AttributeValueBase &av);


} //# NAMESPACE CASA - END

#endif