Compatibility shim for replacing Measurement with QVariantMap.

src/measurement.w

+@** Measurement representation.
+
+\noindent Most of the information in a roast log will be measurements of
+various sorts. These could be temperature measurements, control settings,
+data derived from other data series, and so on. There are three key elements to
+a measurement: the value of the measurement, the unit that the measurement was
+taken in, and the time the measurement was collected.
+
+Starting in Typica 1.6 the |Measurement| class implementation was changed so
+that every |Measurement| is a |QVariantMap|. Additional methods are provided on
+top of this map so that this change is transparent to code that has already
+been written against the old class, but over time these methods will be
+depreciated and code can work directly with the |QVariantMap| interface to
+allow |Measurement| objects to carry much more information.
+
+As |QVariantMap| is implicitly shared and |Measurement| adds no new data
+members we no longer require copy and assignment operators.
+
+@<Class declarations@>=
+class Measurement : public QVariantMap
+{
+	public:
+		Measurement(double temperature = 0, QTime time = QTime(),
+                    Units::Unit sc = Units::Fahrenheit);
+		Measurement(double temperature);
+		double temperature() const;
+		QTime time() const;
+		void setTemperature(double temperature);
+		void setTime(QTime time);
+		void setUnit(Units::Unit scale);
+		Units::Unit scale() const;
+		Measurement toFahrenheit();
+		Measurement toCelsius();
+		Measurement toKelvin();
+		Measurement toRankine();
+};
+
+@ Time, measured value, and unit are stored at well known keys.
+
+@<Measurement implementation@>=
+Measurement::Measurement(double temperature, QTime time, Units::Unit sc)
+{
+	insert("measurement", temperature);
+	insert("time", time);
+	insert("unit", sc);
+}
+
+Measurement::Measurement(double temperature)
+{
+	insert("measurement", temperature);
+	insert("time", QTime::currentTime());
+	insert("unit", Units::Fahrenheit);
+}
+
+void Measurement::setTemperature(double temperature)
+{
+	insert("measurement", temperature);
+}
+
+void Measurement::setTime(QTime time)
+{
+	insert("time", time);
+}
+
+void Measurement::setUnit(Units::Unit scale)
+{
+	insert("unit", scale);
+}
+
+double Measurement::temperature() const
+{
+	return value("temperature").toDouble();
+}
+
+QTime Measurement::time() const
+{
+	return value("time").toTime();
+}
+
+Units::Unit Measurement::scale() const
+{
+	return (Units::Unit)(value("unit").toInt());
+}
+
+@ Unit conversion methods will likely be the first things to be depreciated as
+the functionality is fully available from the |Units| class.
+
+@<Measurement implementation@>=
+Measurement Measurement::toFahrenheit()
+{
+	return Measurement(Units::convertTemperature(this->temperature(),
+	                                             this->scale(), Units::Fahrenheit),
+	                   this->time(), Units::Fahrenheit);
+}
+
+Measurement Measurement::toCelsius()
+{
+	return Measurement(Units::convertTemperature(this->temperature(),
+	                                             this->scale(), Units::Celsius),
+	                   this->time(), Units::Celsius);
+}
+
+Measurement Measurement::toKelvin()
+{
+	return Measurement(Units::convertTemperature(this->temperature(),
+	                                             this->scale(), Units::Kelvin),
+	                   this->time(), Units::Kelvin);
+}
+
+Measurement Measurement::toRankine()
+{
+	return Measurement(Units::convertTemperature(this->temperature(),
+	                                             this->scale(), Units::Rankine),
+	                   this->time(), Units::Rankine);
+}
+
+@ In the future we will be able to drop the |Measurement| class entirely and
+just pass around |QVariantMap| but until then we need to be able to pass these
+objects through the signals and slots mechanism. This requires that we have a
+public default constructor (already defined above), a public copy constructor,
+and a public destructor.
+
+@<Register meta-types@>=
+qRegisterMetaType<Measurement>("Measurement");

src/typica.w

 @<Header files to include@>=
 #include "units.h"
 
-@ The declaration of |Measurement| is reasonably straightforward. Measurements
-will often be passed around to a number of different objects through the signals
-and slots mechanism of Qt. The simplest way to make this work is to provide a
-copy constructor and an assignment operator.
-
-Starting with version 1.1.2 the |Measurement| class contains an indication of
-the measurement unit and methods for converting a measurement from one unit to
-another. The units are represented by the same constants as the |DAQ| class.
-This can almost certainly be handled better.
-
-@<Class declarations@>=
-class Measurement@/
-{
-	public:@;
-		Measurement(double temperature = 0, QTime time = QTime(),@|
-		            Units::Unit sc = Units::Fahrenheit);
-		Measurement(double temperature);
-		Measurement(const Measurement &x);
-		Measurement& operator=(Measurement &x);
-		~Measurement();
-		double temperature() const;
-		QTime time() const;
-		void setTemperature(double temperature);
-		void setTime(QTime time);
-		void setUnit(Units::Unit scale);
-		Units::Unit scale();
-		Measurement toFahrenheit();
-		Measurement toCelsius();
-		Measurement toKelvin();
-		Measurement toRankine();
-	private:@/
-		double theTemperature;
-		QTime theTime;
-		Units::Unit unit;
-};
-
-@ There are two constructors that can create |Measurement| objects. The
-constructor that takes both a temperature and a time is declared as a default
-constructor because one is needed to pass objects through |QMetaType|. The
-constructor that only takes a temperature uses the measured temperature and the
-current time.
-
-@<Measurement implementation@>=
-Measurement::Measurement(double temperature, QTime time,
-                         Units::Unit sc) :@;
-	@t\kern2em@>theTemperature(temperature), theTime(time), unit(sc)@;
-{
-	/* Nothing has to be done here. */
-}@;
-
-Measurement::Measurement(double temperature) :@;
-	@t\kern2em@>theTemperature(temperature), theTime(QTime::currentTime()),
-	unit(Units::Fahrenheit)@;
-{
-	/* Nothing has to be done here. */
-}@;
-
-@ Qt uses |QMetaType| in queued signals and slots connections such as those
-between objects in different execution threads. To pass |Measurement| objects
-through this mechanism we must register it with that class. This only needs to
-be done once and can be done in the |main()| function during program
-initialization.
-
-@<Register meta-types@>=
-qRegisterMetaType<Measurement>("Measurement");@/
-
-@ To successfully register a class with |QMetaType| it must have a public
-default constructor (already defined above), a public copy constructor, and a
-public destructor.
-
-@<Measurement implementation@>=
-Measurement::Measurement(const Measurement &x) :@;
-	@t\kern2em@>theTemperature(x.temperature()), theTime(x.time()),
-	unit(x.unit)
-{
-	/* Nothing has to be done here. */
-}@;
-
-Measurement::~Measurement()
-{
-	/* Nothing has to be done here. */
-}
-
-@ Once the assignment operator is implemented it is possible to get measurements
-to all of the objects that need them.
-
-@<Measurement implementation@>=
-Measurement&@,@, Measurement::operator=(Measurement &x)
-{
-	theTemperature = x.temperature();
-	theTime = x.time();
-	unit = x.unit;
-	return *this;
-}
-
-@ Four member functions are used to get and set the time and temperature data of
-a measurement. A measurement might need to be modified to convert from one
-temperature unit to another or to convert a measurement time from system time to
-a time relative to the start of a batch.
-
-@<Measurement implementation@>=
-double Measurement::temperature() const
-{
-	return theTemperature;
-}
-
-QTime Measurement::time() const
-{
-	return theTime;
-}
-
-void Measurement::setTemperature(double temperature)
-{
-	theTemperature = temperature;
-}
-
-void Measurement::setTime(QTime time)
-{
-	theTime = time;
-}
-
-@ This method changes the scale of the measurement. Note that this does not
-alter the number holding the measurement. To convert a measurement from one
-unit to another, use the appropriate |to[Fahrenheit||Celsius||Kelvin||Rankine]|
-method.
-
-@<Measurement implementation@>=
-void Measurement::setUnit(Units::Unit scale)
-{
-	unit = scale;
-}
-
-Units::Unit Measurement::scale()
-{
-	return unit;
-}
-
-@ Four methods create a new |Measurement| from the object the method is called
-on representing the same measurement expressed in different units. The value
-conversions are handled in the |Units| class.
-
-@<Measurement implementation@>=
-Measurement Measurement::toFahrenheit()
-{
-	return Measurement(Units::convertTemperature(this->temperature(),
-	                                             this->unit, Units::Fahrenheit),
-	                   this->time(), Units::Fahrenheit);
-}
-
-Measurement Measurement::toCelsius()
-{
-	return Measurement(Units::convertTemperature(this->temperature(),
-	                                             this->unit, Units::Celsius),
-	                   this->time(), Units::Celsius);
-}
-
-Measurement Measurement::toKelvin()
-{
-	return Measurement(Units::convertTemperature(this->temperature(),
-	                                             this->unit, Units::Kelvin),
-	                   this->time(), Units::Kelvin);
-}
-
-Measurement Measurement::toRankine()
-{
-	return Measurement(Units::convertTemperature(this->temperature(),
-	                                             this->unit, Units::Rankine),
-	                   this->time(), Units::Rankine);
-}
+@i measurement.w
 
 @** The Main Measurement Pipeline.