ichannelconversion.h

Go to the documentation of this file.

/*
 * Copyright 2021 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
#include <optional>
#include <sstream>
#include <string>
#include <vector>
#include <variant>
 
#include "mdf/iblock.h"
#include "mdf/imetadata.h"
#include "mdf/mdfhelper.h"
 
namespace mdf {
 
enum class ConversionType : uint8_t {
  NoConversion = 0,
 
  Linear = 1,
 
  Rational = 2,
  Algebraic = 3, 
 
  ValueToValueInterpolation = 4,
 
  ValueToValue = 5,
 
  ValueRangeToValue = 6,
 
  ValueToText = 7,
 
  ValueRangeToText = 8,
 
  TextToValue = 9,
 
  TextToTranslation = 10,
 
  BitfieldToText = 11,
  // MDF 3 types
  Polynomial = 30, 
  Exponential = 31, 
  Logarithmic = 32, 
  DateConversion = 33, 
  TimeConversion = 34 
};
 
struct TextConversion {
  double value = 0; 
  std::string text; 
};
 
struct TextRangeConversion {
  double lower = 0; 
  double upper = 0; 
  uint32_t link_text = 0; 
  std::string text; 
};
 
namespace CcFlag {
constexpr uint16_t PrecisionValid = 0x0001; 
constexpr uint16_t RangeValid = 0x0002; 
constexpr uint16_t StatusString = 0x0004; 
}  // namespace CcFlag
 
class IChannelConversion : public IBlock {
 
 public:
  ~IChannelConversion() override = default;
 
  virtual void Name(const std::string& name); 
  [[nodiscard]] virtual std::string Name() const; 
 
  virtual void Description(const std::string& desc); 
  [[nodiscard]] virtual std::string Description() const; 
 
  virtual void Unit(const std::string& unit) = 0; 
  [[nodiscard]] virtual std::string Unit() const = 0; 
  [[nodiscard]] virtual bool IsUnitValid() const = 0; 
 
  virtual void Type(ConversionType type) = 0; 
  [[nodiscard]] virtual ConversionType Type() const = 0; 
 
  [[nodiscard]] virtual bool IsDecimalUsed()
      const = 0; 
  virtual void Decimals(uint8_t decimals); 
  [[nodiscard]] virtual uint8_t Decimals() const = 0; 
 
  [[nodiscard]] virtual IChannelConversion* CreateInverse();
 
  [[nodiscard]] virtual IChannelConversion* Inverse() const;
 
  virtual void Range(double min, double max); 
  [[nodiscard]] virtual std::optional<std::pair<double, double>> Range()
      const; 
 
  virtual void Flags(uint16_t flags); 
  [[nodiscard]] virtual uint16_t Flags() const; 
 
  [[nodiscard]] virtual IMetaData* CreateMetaData();
 
  [[nodiscard]] virtual IMetaData* MetaData() const;
 
  virtual void Formula( const std::string& formula);
  [[nodiscard]] virtual const std::string& Formula() const;
 
  [[nodiscard]] uint16_t NofParameters() const;
 
  void Parameter(uint16_t index, double parameter);
 
  [[nodiscard]] double Parameter(uint16_t index) const;
 
  [[nodiscard]] uint64_t ParameterUint(uint16_t index) const;
  void ParameterUint(uint16_t index, uint64_t parameter);
 
  [[nodiscard]] virtual uint16_t NofReferences() const;
 
  virtual void Reference(uint16_t index, const std::string& text);
 
  [[nodiscard]] virtual std::string Reference(uint16_t index) const;
 
  void ChannelDataType(uint8_t channel_data_type);
 
  template <typename T, typename V>
  bool Convert(const T& channel_value, V& eng_value) const;
 
  template <typename T, typename V = std::string>
  bool Convert(const T& channel_value, std::string& eng_value) const;
 
  template <typename T = std::string, typename V = double>
  bool Convert(const std::string& channel_value, double& eng_value) const;
 
  template <typename T = std::string, typename V = std::string>
  bool Convert(const std::string& channel_value, std::string& eng_value) const {
    if (Type() == ConversionType::TextToTranslation) {
      ConvertTextToTranslation(channel_value, eng_value);
    } else if (Type() == ConversionType::NoConversion) {
      eng_value = channel_value;
    } else {
      return false;
    }
    return true;
  }
 
 protected:
  uint16_t nof_values_ = 0; 
 
  using ParameterList = std::vector<std::variant<uint64_t, double>>;
 
  ParameterList value_list_; 
  uint8_t channel_data_type_ =
      0;  
 
  // The formula and conversion list is used in MDF 3 while MDF4
  // uses the reference list.
  mutable std::string formula_; 
  std::vector<TextConversion> text_conversion_list_; 
  std::vector<TextRangeConversion> text_range_conversion_list_; 
 
  [[nodiscard]] bool IsChannelInteger()
      const; 
  [[nodiscard]] bool IsChannelFloat()
      const; 
 
  virtual bool ConvertLinear(double channel_value, double& eng_value)
      const; 
  virtual bool ConvertRational(double channel_value, double& eng_value)
      const; 
  virtual bool ConvertAlgebraic(double channel_value, double& eng_value)
      const; 
  virtual bool ConvertValueToValueInterpolate(double channel_value,
      double& eng_value) const; 
  virtual bool ConvertValueToValue(double channel_value,
      double& eng_value) const; 
  virtual bool ConvertValueRangeToValue(double channel_value,
      double& eng_value) const; 
 
  virtual bool ConvertValueToText(double channel_value,
      std::string& eng_value) const; 
  virtual bool ConvertValueRangeToText(double channel_value,
      std::string& eng_value) const; 
  virtual bool ConvertTextToValue(const std::string& channel_value,
      double& eng_value) const; 
  virtual bool ConvertTextToTranslation(const std::string& channel_value,
      std::string& eng_value) const; 
  virtual bool ConvertPolynomial(double channel_value, double& eng_value)
      const; 
  virtual bool ConvertLogarithmic(double channel_value,
      double& eng_value) const; 
  virtual bool ConvertExponential(double channel_value,
      double& eng_value) const; 
};
 
template <typename T, typename V>
inline bool IChannelConversion::Convert(const T& channel_value,
  V& eng_value) const {
  bool valid = false;
  double value = 0.0;
  switch (Type()) {
    case ConversionType::Linear: {
      valid = ConvertLinear(static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
 
    case ConversionType::Rational: {
      valid = ConvertRational(static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
 
    case ConversionType::Algebraic: {
      valid = ConvertAlgebraic(static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
 
    case ConversionType::ValueToValueInterpolation: {
      valid = ConvertValueToValueInterpolate(
          static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
 
    case ConversionType::ValueToValue: {
      valid = ConvertValueToValue(static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
 
    case ConversionType::ValueRangeToValue: {
      valid =
          ConvertValueRangeToValue(static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
 
    case ConversionType::ValueToText: {
      std::string text;
      valid = ConvertValueToText(static_cast<double>(channel_value), text);
      std::istringstream s(text);
      s >> eng_value;
      break;
    }
 
    case ConversionType::ValueRangeToText: {
      std::string text;
      valid =
          ConvertValueRangeToText(static_cast<double>(channel_value), text);
      std::istringstream s(text);
      s >> eng_value;
      break;
    }
 
    case ConversionType::Polynomial: {
      valid = ConvertPolynomial(static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
 
    case ConversionType::Exponential: {
      valid = ConvertExponential(static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
 
    case ConversionType::Logarithmic: {
      valid = ConvertLogarithmic(static_cast<double>(channel_value), value);
      eng_value = static_cast<V>(value);
      break;
    }
    case ConversionType::NoConversion:
    default: {
      eng_value = static_cast<V>(channel_value);
      valid = true;
      break;
    }
  }
  return valid;
}
 
template <typename T, typename V>
inline bool IChannelConversion::Convert(const T& channel_value,
    std::string& eng_value) const {
  bool valid = false;
  double value = 0.0;
  switch (Type()) {
    case ConversionType::Linear: {
      valid = ConvertLinear(static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::Rational: {
      valid = ConvertRational(static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::Algebraic: {
      valid = ConvertAlgebraic(static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::ValueToValueInterpolation: {
      valid = ConvertValueToValueInterpolate(
          static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::ValueToValue: {
      valid = ConvertValueToValue(static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::ValueRangeToValue: {
      valid =
          ConvertValueRangeToValue(static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::ValueToText: {
      valid =
          ConvertValueToText(static_cast<double>(channel_value), eng_value);
      break;
    }
 
    case ConversionType::ValueRangeToText: {
      valid = ConvertValueRangeToText(static_cast<double>(channel_value),
                                      eng_value);
      break;
    }
 
    case ConversionType::Polynomial: {
      valid = ConvertPolynomial(static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::Exponential: {
      valid = ConvertExponential(static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::Logarithmic: {
      valid = ConvertLogarithmic(static_cast<double>(channel_value), value);
      eng_value =
          MdfHelper::FormatDouble(value, IsDecimalUsed() ? Decimals() : 6);
      break;
    }
 
    case ConversionType::NoConversion:
    default: {
      eng_value = MdfHelper::FormatDouble(static_cast<double>(channel_value),
                                          IsDecimalUsed() ? Decimals() : 6);
      valid = true;
      break;
    }
  }
  return valid;
}
 
template <typename T, typename V>
bool IChannelConversion::Convert(const std::string& channel_value,
    double& eng_value) const {
  if (Type() == ConversionType::TextToValue) {
    ConvertTextToValue(channel_value, eng_value);
  } else if (Type() == ConversionType::NoConversion) {
    eng_value = std::stod(channel_value);
  } else {
    return false;
  }
  return true;
}
 
}  // namespace mdf