Unit.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 UNIT_HPP
#define UNIT_HPP

#include <boost/serialization/nvp.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception/info.hpp>
#include <duds/general/SignExtend.hpp>
#include <stdexcept>
#include <cstdint>

namespace duds { namespace data {

using duds::general::SignExtend;

struct UnitError : virtual std::exception, virtual boost::exception { };

struct UnitRangeError : UnitError { };

typedef boost::error_info<struct Info_unitexp, int>  BadUnitExponent;

typedef boost::error_info<struct Info_unitname, std::string>  BadUnit;

struct UnitMismatch : UnitError { };

struct UnitBadConversion : UnitError { };

class Unit {
    std::int32_t u;
    friend class boost::serialization::access;
    template <class A>
    void serialize(A &a, const unsigned int) {
        a & BOOST_SERIALIZATION_NVP(u);
    }
public:
    std::int32_t value() const {
        return u;
    }
    Unit() = default;
    Unit(const Unit &) = default;
    constexpr Unit(std::int32_t U) : u(U) { }
    Unit(int A, int cd, int K, int kg, int m, int mol, int s,
        int rad = 0, int sr = 0);
    int ampere() const {
        return SignExtend<4>(u & 0xF);
    }
    int candela() const {
        return SignExtend<4>((u & 0xF0) >> 4);
    }
    int kelvin() const {
        return SignExtend<4>((u & 0xF00) >> 8);
    }
    int kilogram() const {
        return SignExtend<4>((u & 0xF000) >> 12);
    }
    int meter() const {
        return SignExtend<4>((u & 0xF0000) >> 16);
    }
    int mole() const {
        return SignExtend<4>((u & 0xF00000) >> 20);
    }
    int second() const {
        return SignExtend<4>((u & 0xF000000) >> 24);
    }
    int radian() const {
        return SignExtend<2>((u & 0x30000000) >> 28);
    }
    int steradian() const {
        return SignExtend<2>((u & 0xC0000000) >> 30);
    }
    int amp() const {
        return ampere();
    }
    int metre() const {
        return meter();
    }
    int A() const {
        return ampere();
    }
    int cd() const {
        return candela();
    }
    int K() const {
        return kelvin();
    }
    int kg() const {
        return kilogram();
    }
    int m() const {
        return meter();
    }
    int mol() const {
        return mole();
    }
    int s() const {
        return second();
    }
    int rad() const {
        return radian();
    }
    int sr() const {
        return steradian();
    }
    void ampere(int e) {
        u = (u & 0xFFFFFFF0) | (e & 0xF);
    }
    void candela(int e) {
        u = (u & 0xFFFFFF0F) | ((e & 0xF) << 4);
    }
    void kelvin(int e) {
        u = (u & 0xFFFFF0FF) | ((e & 0xF) << 8);
    }
    void kilogram(int e) {
        u = (u & 0xFFFF0FFF) | ((e & 0xF) << 12);
    }
    void meter(int e) {
        u = (u & 0xFFF0FFFF) | ((e & 0xF) << 16);
    }
    void mole(int e) {
        u = (u & 0xFF0FFFFF) | ((e & 0xF) << 20);
    }
    void second(int e) {
        u = (u & 0xF0FFFFFF) | ((e & 0xF) << 24);
    }
    void radian(int e) {
        u = (u & 0xCFFFFFFF) | ((e & 0x3) << 28);
    }
    void steradian(int e) {
        u = (u & 0x3FFFFFFF) | ((e & 0x3) << 30);
    }
    void amp(int e) {
        ampere(e);
    }
    void metre(int e) {
        meter(e);
    }
    void A(int e) {
        ampere(e);
    }
    void cd(int e) {
        candela(e);
    }
    void K(int e) {
        kelvin(e);
    }
    void kg(int e) {
        kilogram(e);
    }
    void m(int e) {
        meter(e);
    }
    void mol(int e) {
        mole(e);
    }
    void s(int e) {
        second(e);
    }
    void rad(int e) {
        radian(e);
    }
    void sr(int e) {
        steradian(e);
    }
    void setAmpere(int e);
    void setCandela(int e);
    void setKelvin(int e);
    void setKilogram(int e);
    void setMeter(int e);
    void setMole(int e);
    void setSecond(int e);
    void setRadian(int e);
    void setSteradian(int e);
    void setAmp(int e) {
        setAmpere(e);
    }
    void setMetre(int e) {
        setMeter(e);
    }
    bool unitless() const {
        return u == 0;
    }
    void clear() {
        u = 0;
    }
    const Unit operator * (const Unit &U) const;
    const Unit operator / (const Unit &U) const;
    Unit &operator *= (const Unit &U);
    Unit &operator /= (const Unit &U);
    bool operator < (const Unit &U) const {
        return u < U.u;
    }
    bool operator > (const Unit &U) const {
        return u > U.u;
    }
    bool operator <= (const Unit &U) const {
        return u <= U.u;
    }
    bool operator >= (const Unit &U) const {
        return u >= U.u;
    }
    bool operator == (const Unit &U) const {
        return u == U.u;
    }
    bool operator != (const Unit &U) const {
        return u != U.u;
    }
};

} }

#define DUDS_UNIT_VALUE(A, cd, K, kg, m, mol, s, rad, sr) \
    (((A) & 0xF) | (((cd) & 0xF) << 4) | (((K) & 0xF) << 8) | \
    (((kg) & 0xF) << 12) | (((m) & 0xF) << 16) | (((mol) & 0xF) << 20) | \
    (((s) & 0xF) << 24) | (((rad) & 3) << 28) | (((sr) & 3) << 30))

#endif        //  #ifndef UNIT_HPP