Quantity.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 QUANTITY_HPP
#define QUANTITY_HPP

#include <duds/data/Units.hpp>
#include <duds/general/Errors.hpp>
#include <duds/time/interstellar/Interstellar.hpp>

namespace duds { namespace data {

struct Quantity {
    double value;
    Unit unit;
    Quantity() = default;
    Quantity(const Quantity &) = default;
    constexpr Quantity(const double &v, const Unit &u) : value(v), unit(u) { }
    template <class Duration>
    Quantity(const Duration &d) : unit(duds::data::units::Second) {
        std::chrono::duration<double> sec =
            std::chrono::duration_cast<std::chrono::seconds>(d);
        value = sec.count();
    }
    Quantity operator + (const Quantity &q) const;
    Quantity operator - (const Quantity &q) const;
    Quantity operator * (const Quantity &q) const {
        return Quantity(value * q.value, unit * q.unit);
    }
    Quantity operator * (double s) const {
        return Quantity(value * s, unit);
    }
    Quantity operator / (const Quantity &q) const {
        return Quantity(value / q.value, unit / q.unit);
    }
    Quantity operator / (double s) const {
        return Quantity(value / s, unit);
    }
    Quantity &operator += (const Quantity &q);
    Quantity &operator -= (const Quantity &q);
    Quantity &operator *= (const Quantity &q);
    Quantity &operator *= (double s) {
        value *= s;
        return *this;
    }
    Quantity &operator /= (const Quantity &q);
    Quantity &operator /= (double s) {
        value /= s;
        return *this;
    }
    bool operator < (const Quantity &q) const;
    bool operator > (const Quantity &q) const;
    bool operator <= (const Quantity &q) const;
    bool operator >= (const Quantity &q) const;
    bool operator == (const Quantity &q) const {
        return (unit == q.unit) && (value == q.value);
    }
    bool operator != (const Quantity &q) const {
        return (unit != q.unit) || (value != q.value);
    }
    template <class Duration>
    void toDuration(Duration &d) const {
        if (unit != duds::data::units::Second) {
            DUDS_THROW_EXCEPTION(UnitBadConversion() << BadUnit(unit));
        }
        d = Duration(typename Duration::rep(value *
            (double)(Duration::period::num) /
            (double)(Duration::period::den)
        ) );
    }
    template <class Duration>
    Duration toDuration() const {
        if (unit != duds::data::units::Second) {
            DUDS_THROW_EXCEPTION(UnitBadConversion() << BadUnit(unit));
        }
        return Duration(typename Duration::rep(value *
            (double)(Duration::period::num) /
            (double)(Duration::period::den)
        ) );
    }
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);
    }
};

inline Quantity operator * (double s, const Quantity &q) {
    return q * s;
}

inline Quantity operator / (double s, const Quantity &q) {
    return Quantity(s / q.value, q.unit);
}

/*
 * Assigns a duration in femtoseconds.
 * @param q  The quantity to convert; must be in seconds.
 * @throw UnitBadConversion  The quantity is not in seconds.
 * /
::duds::time::interstellar::Femtoseconds &operator = (
    ::duds::time::interstellar::Femtoseconds &fs, const Quantity &q
);

/ **
 * Assigns a duration in nanoseconds.
 * @param q  The quantity to convert; must be in seconds.
 * @throw UnitBadConversion  The quantity is not in seconds.
 * /
::duds::time::interstellar::Nanoseconds &operator = (
    ::duds::time::interstellar::Nanoseconds &ns, const Quantity &q
);
*/
} }

#endif        //  #ifndef QUANTITY_HPP