dataTypes.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <limits>
#include <sstream>
#include <string>
#include <type_traits>
 
namespace nmealib {
namespace nmea2000 {
 
template<typename Traits>
class DataType {
public:
    static constexpr double MIN = Traits::MIN;
    static constexpr double MAX = Traits::MAX;
    static constexpr double RESOLUTION = Traits::RESOLUTION;
    using RawType = typename Traits::RawType;
    using TargetType = typename Traits::TargetType;
 
    static DataType fromValue(TargetType value) {
        const double physicalValue = static_cast<double>(value);
        const double clampedValue = std::clamp(physicalValue, MIN, MAX);
 
        double scaled = clampedValue - MIN;
        scaled /= (MAX - MIN);
        scaled *= (static_cast<double>(Traits::RAW_MAX) - static_cast<double>(Traits::RAW_MIN));
        scaled += static_cast<double>(Traits::RAW_MIN);
        scaled = std::round(scaled / RESOLUTION) * RESOLUTION;
 
        return DataType(static_cast<RawType>(scaled));
    }
 
    static constexpr DataType fromRaw(RawType raw) noexcept {
        return DataType(raw);
    }
 
    constexpr bool isValid() const noexcept {
        return value_ >= Traits::RAW_MIN && value_ <= Traits::RAW_MAX;
    }
 
    constexpr TargetType getValue() const noexcept {
        double scaled = static_cast<double>(value_) - static_cast<double>(Traits::RAW_MIN);
        scaled /= (static_cast<double>(Traits::RAW_MAX) - static_cast<double>(Traits::RAW_MIN));
        scaled *= (MAX - MIN);
        scaled += MIN;
        return static_cast<TargetType>(scaled);
    }
    
    RawType getRaw() const noexcept {
        return value_;
    }
    
    std::string toString() const {
        std::ostringstream oss;
        if constexpr (std::is_integral_v<TargetType>) {
            oss << static_cast<long long>(getValue());
        } else {
            oss << std::fixed << std::setprecision(getPrecision()) << getValue();
        }
        return oss.str();
    }
 
    // Operators
    constexpr bool operator==(const DataType& other) const noexcept {
        return value_ == other.value_;
    }
    constexpr bool operator!=(const DataType& other) const noexcept {
        return value_ != other.value_;
    }
    constexpr bool operator<(const DataType& other) const noexcept {
        return value_ < other.value_;
    }
    constexpr bool operator<=(const DataType& other) const noexcept {
        return value_ <= other.value_;
    }
    constexpr bool operator>(const DataType& other) const noexcept {
        return value_ > other.value_;
    }
    constexpr bool operator>=(const DataType& other) const noexcept {
        return value_ >= other.value_;
    }
 
private:
    RawType value_;
 
    // Block default construction without parameters to enforce explicit initialization
    constexpr explicit DataType(RawType value) noexcept : value_(value) {}
 
    static constexpr int getPrecision() noexcept {
        if constexpr (RESOLUTION >= 1.0) return 0;
        int p = 0;
        double r = RESOLUTION;
        while (r < 1.0 && p < 15) { r *= 10; p++; }
        return p;
    }
};
 
struct DistanceTraits {
    static constexpr double MIN = 0;
    static constexpr double MAX = 4.295e7;
    static constexpr double RESOLUTION = 1e-2;
    using RawType = uint32_t;
    using TargetType = float;
    static constexpr RawType RAW_MIN = std::numeric_limits<RawType>::min();
    static constexpr RawType RAW_MAX = std::numeric_limits<RawType>::max();
};
struct SpeedTraits {
    static constexpr double MIN = 0;
    static constexpr double MAX = 655.32;
    static constexpr double RESOLUTION = 1e-2;
    using RawType = uint16_t;
    using TargetType = float;
    static constexpr RawType RAW_MIN = std::numeric_limits<RawType>::min();
    static constexpr RawType RAW_MAX = std::numeric_limits<RawType>::max();
};
struct AngleTraits {
    static constexpr double MIN = 0;
    static constexpr double MAX = 2 * M_PI;
    static constexpr double RESOLUTION = 1e-4;
    using RawType = uint16_t;
    using TargetType = float;
    static constexpr RawType RAW_MIN = std::numeric_limits<RawType>::min();
    static constexpr RawType RAW_MAX = std::numeric_limits<RawType>::max();
};
struct SignedAngleTraits {
    static constexpr double MIN = -M_PI;
    static constexpr double MAX = M_PI;
    static constexpr double RESOLUTION = 1e-4;
    using RawType = uint16_t;
    using TargetType = float;
    static constexpr RawType RAW_MIN = std::numeric_limits<RawType>::min();
    static constexpr RawType RAW_MAX = std::numeric_limits<RawType>::max();
};
struct HalfByteTraits {
    static constexpr double MIN = 0;
    static constexpr double MAX = 15;
    static constexpr double RESOLUTION = 1;
    using RawType = uint8_t;
    using TargetType = uint8_t;
    static constexpr RawType RAW_MIN = 0;
    static constexpr RawType RAW_MAX = 15;
};
struct ByteTraits {
    static constexpr double MIN = 0;
    static constexpr double MAX = 255;
    static constexpr double RESOLUTION = 1;
    using RawType = uint8_t;
    using TargetType = uint8_t;
    static constexpr RawType RAW_MIN = std::numeric_limits<RawType>::min();
    static constexpr RawType RAW_MAX = std::numeric_limits<RawType>::max();
};
struct LatitudeTraits {
    static constexpr double MIN = -90;
    static constexpr double MAX = 90;
    static constexpr double RESOLUTION = 1e-7;
    using RawType = int32_t;
    using TargetType = float;
    static constexpr RawType RAW_MIN = -90 * static_cast<RawType>(1e7);
    static constexpr RawType RAW_MAX = 90 * static_cast<RawType>(1e7);
};
struct LongitudeTraits {
    static constexpr double MIN = -180;
    static constexpr double MAX = 180;
    static constexpr double RESOLUTION = 1e-7;
    using RawType = int32_t;
    using TargetType = float;
    static constexpr RawType RAW_MIN = -180 * static_cast<RawType>(1e7);
    static constexpr RawType RAW_MAX = 180 * static_cast<RawType>(1e7);
};
struct AngularRateTraits {
    static constexpr double MIN = -67;
    static constexpr double MAX = 67;
    static constexpr double RESOLUTION = (1 / 32) * 1e-6;
    using RawType = int32_t;
    using TargetType = double;
    static constexpr RawType RAW_MIN = std::numeric_limits<RawType>::min();
    static constexpr RawType RAW_MAX = std::numeric_limits<RawType>::max();
};
struct AccelerationTraits {
    static constexpr double MIN = -327.64;
    static constexpr double MAX = 327.64;
    static constexpr double RESOLUTION = 1e-2;
    using RawType = int16_t;
    using TargetType = float;
    static constexpr RawType RAW_MIN = std::numeric_limits<RawType>::min();
    static constexpr RawType RAW_MAX = std::numeric_limits<RawType>::max();
};
 
using Distance = DataType<DistanceTraits>;
 
using Speed = DataType<SpeedTraits>;
 
using HalfByte = DataType<HalfByteTraits>;
 
using Byte = DataType<ByteTraits>;
 
using Angle = DataType<AngleTraits>;
 
using SignedAngle = DataType<SignedAngleTraits>;
 
using Latitude = DataType<LatitudeTraits>;
 
using Longitude = DataType<LongitudeTraits>;
 
using AngularRate = DataType<AngularRateTraits>;
 
using Acceleration = DataType<AccelerationTraits>;
 
} // namespace nmea2000
} // namespace nmealib