ExtendedUnit.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#ifndef EXTENDEDUNIT_HPP
#define EXTENDEDUNIT_HPP

#include <duds/general/Errors.hpp>
#include <duds/data/Unit.hpp>
#include <boost/serialization/split_member.hpp>

namespace duds { namespace data {

// needed for celsius, liter

class ExtendedUnit {
    Unit unit;
    union {
        std::uint32_t scaloff;
        struct {
            unsigned int mant  : 20;
            int exp            : 7;
            int sign           : 1;
            int scale : 4;
        };
    };
    // serialization support
    friend class boost::serialization::access;
    template <class A>
    void save(A &a, const unsigned int) const {
        a & BOOST_SERIALIZATION_NVP(unit);
        // prevent differences in bitfields across platforms from causing
        // different values for scaloff; assume for now that the archive will
        // handle endianness differences
        std::uint32_t packed = mant | (exp << 20) | (sign << 27) | (scale << 28);
        a & BOOST_SERIALIZATION_NVP(packed);
    }
    template <class A>
    void load(A &a, const unsigned int) {
        a & BOOST_SERIALIZATION_NVP(unit);
        std::uint32_t packed;
        a & BOOST_SERIALIZATION_NVP(packed);
        // prevent differences in bitfields across platforms from causing
        // different values for scaloff; assume for now that the archive will
        // handle endianness differences
        mant = packed & 0xFFFFF;
        exp = (packed >> 20) & 0x7F;
        sign = (packed >> 27) & 1;
        scale = packed >> 28;
    }
    BOOST_SERIALIZATION_SPLIT_MEMBER();
    constexpr ExtendedUnit(Unit u, std::uint32_t s) : unit(u), scaloff(s) { }
public:
    ExtendedUnit() = default;
    ExtendedUnit(const ExtendedUnit &) = default;
    constexpr ExtendedUnit(Unit u) : unit(u), scaloff(0) { }
    template <typename O>
    ExtendedUnit(Unit u, O o, int s) : unit(u), scale(s) {
        if ((s > 7) || (s < -8)) {
            DUDS_THROW_EXCEPTION(UnitRangeError());
        }
        offset(o);
    }
    bool canConvertToUnit() const;
    void offset(float o);
    float offsetf() const;
    void offset(double o);
    double offset() const;
    const Unit &base() const {
        return unit;
    }
    int ampere() const {
        return unit.ampere();
    }
    int candela() const {
        return unit.candela();
    }
    int kelvin() const {
        return unit.kelvin();
    }
    int kilogram() const {
        return unit.kilogram();
    }
    int meter() const {
        return unit.meter();
    }
    int mole() const {
        return unit.mole();
    }
    int second() const {
        return unit.second();
    }
    int radian() const {
        return unit.radian();
    }
    int steradian() const {
        return unit.steradian();
    }
    int amp() const {
        return unit.ampere();
    }
    int metre() const {
        return unit.meter();
    }
    int A() const {
        return unit.ampere();
    }
    int cd() const {
        return unit.candela();
    }
    int K() const {
        return unit.kelvin();
    }
    int kg() const {
        return unit.kilogram();
    }
    int m() const {
        return unit.meter();
    }
    int mol() const {
        return unit.mole();
    }
    int s() const {
        return unit.second();
    }
    int rad() const {
        return unit.radian();
    }
    int sr() const {
        return unit.steradian();
    }
    void ampere(int e) {
        unit.ampere(e);
    }
    void candela(int e) {
        unit.candela(e);
    }
    void kelvin(int e) {
        unit.kelvin(e);
    }
    void kilogram(int e) {
        unit.kilogram(e);
    }
    void meter(int e) {
        unit.meter(e);
    }
    void mole(int e) {
        unit.mole(e);
    }
    void second(int e) {
        unit.second(e);
    }
    void radian(int e) {
        unit.radian(e);
    }
    void steradian(int e) {
        unit.steradian(e);
    }
    void amp(int e) {
        unit.ampere(e);
    }
    void metre(int e) {
        unit.meter(e);
    }
    void A(int e) {
        unit.ampere(e);
    }
    void cd(int e) {
        unit.candela(e);
    }
    void K(int e) {
        unit.kelvin(e);
    }
    void kg(int e) {
        unit.kilogram(e);
    }
    void m(int e) {
        unit.meter(e);
    }
    void mol(int e) {
        unit.mole(e);
    }
    void s(int e) {
        second(e);
    }
    void rad(int e) {
        unit.radian(e);
    }
    void sr(int e) {
        unit.steradian(e);
    }
    void setAmpere(int e) {
        unit.setAmpere(e);
    }
    void setCandela(int e) {
        unit.setCandela(e);
    }
    void setKelvin(int e) {
        unit.setKelvin(e);
    }
    void setKilogram(int e) {
        unit.setKilogram(e);
    }
    void setMeter(int e) {
        unit.setMeter(e);
    }
    void setMole(int e) {
        unit.setMole(e);
    }
    void setSecond(int e) {
        unit.setSecond(e);
    }
    void setRadian(int e) {
        unit.setRadian(e);
    }
    void setSteradian(int e) {
        unit.setSteradian(e);
    }
    void setAmp(int e) {
        unit.setAmpere(e);
    }
    void setMetre(int e) {
        unit.setMeter(e);
    }
    bool unitless() const {
        return unit.unitless();
    }
    const ExtendedUnit operator * (const Unit &U) const;
    const ExtendedUnit operator / (const Unit &U) const;
    ExtendedUnit &operator *= (const Unit &U);
    ExtendedUnit &operator /= (const Unit &U);
    ExtendedUnit &operator = (const Unit &U);
    bool operator < (const ExtendedUnit &U) const {
        return ((unit == U.unit) && (scaloff < U.scaloff)) || (unit < U.unit);
    }
    bool operator > (const ExtendedUnit &U) const {
        return ((unit == U.unit) && (scaloff > U.scaloff)) || (unit > U.unit);
    }
    bool operator <= (const ExtendedUnit &U) const {
        return ((unit == U.unit) && (scaloff <= U.scaloff)) || (unit <= U.unit);
    }
    bool operator >= (const ExtendedUnit &U) const {
        return ((unit == U.unit) && (scaloff >= U.scaloff)) || (unit >= U.unit);
    }
    bool operator == (const ExtendedUnit &U) const {
        return (unit == U.unit) && (scaloff == U.scaloff);
    }
    bool operator != (const ExtendedUnit &U) const {
        return (unit != U.unit) || (scaloff != U.scaloff);
    }
};

template <class Q = double>
struct ExtendedQuantity {
    Q value;
    ExtendedUnit unit;
private:
    // serialization support
    friend class boost::serialization::access;
    template <class A>
    void serialize(A &a, const unsigned int) {
        a & BOOST_SERIALIZATION_NVP(value);
        a & BOOST_SERIALIZATION_NVP(unit);
    }
};

} }

#endif        //  #ifndef EXTENDEDUNIT_HPP