measurement-unit.h

#ifndef MEASUREMENT_UNIT_H
#define MEASUREMENT_UNIT_H

#include <map>
#include <set>
#include <string>

namespace fnss {

class MeasurementUnit {

public:
        typedef std::map <std::string, double> conversionsMapType;

        MeasurementUnit(const std::string &base_);

        MeasurementUnit(const std::string &base_,
                                        const conversionsMapType &conversions_);

        double convert(const std::string &unit) const;

        double convert(const std::string &unit1, const std::string &unit2) const;

        std::string getBaseUnit() const;

        std::set <std::string> getAllUnits() const;

        void addConversion(std::string unit, double multiplier);

        void addConversions(const conversionsMapType &conversions_);

        MeasurementUnit& combine(const MeasurementUnit &other);

        MeasurementUnit& operator=(const MeasurementUnit &other);

        static MeasurementUnit prefixDerivation(const MeasurementUnit &prefix,
                                                                                        const MeasurementUnit &target);

        static MeasurementUnit fractionalDerivation(const MeasurementUnit &numerator,
                                                                                                const MeasurementUnit &denominator,
                                                                                                const std::string &separator);

        class UnknownConversionException : public std::exception {
        public:
                UnknownConversionException(const std::string &unit1,
                                                                        const std::string &unit2) throw() {
                        this->exceptionStr = "Unknown conversion from unit " + unit1
                                                                + " to unit " + unit2 + ".";
                }

                ~UnknownConversionException() throw() {
                }

                const char* what() const throw() {
                        return this->exceptionStr.c_str();
                }

        private:
                std::string exceptionStr;
        };

        class BaseMismatchException : public std::exception {
        public:
                BaseMismatchException(const std::string &base1,
                                                                const std::string &base2) throw() {
                        this->exceptionStr = "Base unit mismatch: " + base1
                                                                + " and " + base2 + ".";
                }

                ~BaseMismatchException() throw() {
                }

                const char* what() const throw() {
                        return this->exceptionStr.c_str();
                }

        private:
                std::string exceptionStr;
        };

private:
        //Append the base unit to the \c conversions map, with a multiplier of 1.
        static conversionsMapType appendBase(const conversionsMapType &conversions,
                                                                                const std::string &base);


        const std::string base; //Base unit this object operates with.

        //Map of all possible conversions to the base unit.
        conversionsMapType conversions;
};

} //namespace

#endif //MEASUREMENT_UNIT_H