MConvertBase.h

Classes

MConvertBase -- Conversion of Measures Base (full description)
Global Functions -- Global functions (full description)

class MConvertBase

Interface

Public Members
virtual ~MConvertBase()
virtual void setModel(const Measure &val) = 0
virtual void set(const MeasValue &val) = 0
virtual void set(const Unit &inunit) = 0
virtual void addMethod(uInt method) = 0
virtual void addFrameType(uInt tp) = 0
virtual Int nMethod() const = 0
virtual uInt getMethod(uInt which) const = 0
virtual void print(ostream &os) const = 0

Description

Review Status

Date Reviewed:
yyyy/mm/dd
Programs:
Tests:

Prerequisite

Etymology

Synopsis

MConvertBase can convert a Measure to the same type of Measure in a different reference frame. The MConvertBase is a templated class, but has typedefs for the allowed conversions, like MEpoch::Convert.
The basic operation is to create a MConvertBase with either of: An empty MeasRef indicates no conversion
. The constructor, and set functions, analyse the 'template' Measure and the output reference frame, and construct a pointer (in practice a list of pointers to bypass the necessity of creating too many conversion functions) to a conversion routine. Functionals will maybe used in a later version in stead of a vector of function pointers. During the implementation process, I have, for a variety of reasons, changed the list of function pointers to a list of numbers, with the Measure having just a doConvert() function containing an appropiate switch statement.
Actual conversions are done with the () operator, which produces a new MEpoch (or other Measure).
Possible arguments are (MVEpoch is used here generic, and indicates the internal format of a Measure; possibly, to make sure distinction between values with and without units is possible, even simple Measures will have their own internal class format, e.g. MVDouble. This will also aid in the possibility that I am still pursuing to have a fully dynamic conversion possibility. However, to be able to use pointers to functions in any reasonable way for all possible input and output types, a multi-level approach is necessary, with all possible datatypes derived from some MeasValue.): Float versions will be produced if necessary.
The conversion analyser expects that all Measure classes have a set of routines to do the actual analysing and conversion.
If the standard conversion is not sufficient, additional methods can be added at the end of the list with the addMethod() member function, or at the beginning of the list with insertMethod(). The whole list can be cleared with clearMethod().
To ease the specification of the Method, each Measure has a typedef (e.g. MEpoch_ConvType) specifying the Method type.

Example

See Measure for an example

Motivation

Conversion of Measures will in general be done on a series of values. Separating the analysis of the calculations necessary for the conversion from the actual conversion could speed up the process.

To Do

Member Description

virtual ~MConvertBase()

virtual void setModel(const Measure &val) = 0

Set a new model for the conversion

virtual void set(const MeasValue &val) = 0

Set a new model value only

virtual void set(const Unit &inunit) = 0

Set a new model unit only

virtual void addMethod(uInt method) = 0

Add a method (Note: uInt should be an enum from the appropiate Measure)

virtual void addFrameType(uInt tp) = 0

Add a FrameTypes used (as specified in MeasFrame::FrameTypes)

virtual Int nMethod() const = 0

Get number of methods

virtual uInt getMethod(uInt which) const = 0

Get method

virtual void print(ostream &os) const = 0

Print a conversion engine

Global functions (source)

Interface

Private Members
ostream &operator<<( ostream &os, const MConvertBase &mc)

Description

Member Description

ostream &operator<<( ostream &os, const MConvertBase &mc)

Output decalration