ichannelobserver.h

Go to the documentation of this file.

/*
 * Copyright 2021 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
#include <string>
#include <vector>
 
#include "mdf/ichannel.h"
#include "mdf/isampleobserver.h"
#include "mdf/mdfhelper.h"
 
namespace mdf {
 
class IChannelObserver : public ISampleObserver {
 protected:
   const IChannel& channel_; 
   bool read_vlsd_data_ = true; 
 
  std::vector<uint64_t> offset_list_; 
  std::vector<bool> valid_list_; 
 
  virtual bool GetSampleUnsigned(uint64_t sample, uint64_t& value, uint64_t array_index)
      const = 0; 
  virtual bool GetSampleSigned(uint64_t sample, int64_t& value, uint64_t array_index)
      const = 0; 
  virtual bool GetSampleFloat(uint64_t sample, double& value, uint64_t array_index)
      const = 0; 
  virtual bool GetSampleText(uint64_t sample, std::string& value, uint64_t array_index)
      const = 0; 
  virtual bool GetSampleByteArray(uint64_t sample, std::vector<uint8_t>& value)
      const = 0; 
 
 public:
  explicit IChannelObserver(const IDataGroup& dataGroup, const IChannel& channel); 
 
  ~IChannelObserver() override = default; 
 
  IChannelObserver() = delete;
  IChannelObserver(const IChannelObserver&) = delete;
  IChannelObserver(IChannelObserver&&) = delete;
  IChannelObserver& operator=(const IChannelObserver&) = delete;
  IChannelObserver& operator=(IChannelObserver&&) = delete;
 
  [[nodiscard]] virtual uint64_t NofSamples()
      const = 0; 
 
  [[nodiscard]] std::string Name() const; 
 
  [[nodiscard]] std::string Unit() const; 
 
  [[nodiscard]] const IChannel& Channel() const;
 
  [[nodiscard]] bool IsMaster() const; 
 
  [[nodiscard]] bool IsArray() const; 
 
  [[nodiscard]] std::vector<uint64_t> Shape() const;
 
  void ReadVlsdData(bool read_vlsd_data);
 
  [[nodiscard]] bool ReadVlsdData() const { return read_vlsd_data_; }
 
  [[nodiscard]] uint64_t ArraySize() const;
 
  template <typename V>
  bool GetChannelValue(uint64_t sample, V& value, uint64_t array_index = 0 ) const;
 
  template<typename V>
  std::vector<bool> GetChannelSamples(std::vector<V>& values) const;
 
  template<typename V>
  std::vector<bool> GetChannelValues(uint64_t sample,
                                     std::vector<V>& values) const;
 
  template <typename V>
  bool GetEngValue(uint64_t sample, V& value, uint64_t array_index = 0) const;
 
  template<typename V>
  std::vector<bool> GetEngSamples(std::vector<V>& values) const;
 
  template<typename V>
  std::vector<bool> GetEngValues(uint64_t sample, std::vector<V>& values) const;
 
  [[nodiscard]] std::string EngValueToString(uint64_t sample) const;
 
  [[nodiscard]] const std::vector<uint64_t>& GetOffsetList() const {
     return offset_list_;
  }
 
  [[nodiscard]] const std::vector<bool>& GetValidList() const {
    return valid_list_;
  }
 
};
 
template <typename V>
bool IChannelObserver::GetChannelValue(uint64_t sample, V& value, uint64_t array_index) const {
  bool valid = false;
  value = {};
  switch (channel_.DataType()) {
    case ChannelDataType::CanOpenDate:
    case ChannelDataType::CanOpenTime: {
      // All times are stored as ns since 1970 (uint64_t)
      uint64_t v = 0;  // ns since 1970
      valid = GetSampleUnsigned(sample, v, array_index);
      value = static_cast<V>(v);
      break;
    }
 
    case ChannelDataType::UnsignedIntegerLe:
    case ChannelDataType::UnsignedIntegerBe: {
      uint64_t v = 0;
      valid = GetSampleUnsigned(sample, v, array_index);
      value = static_cast<V>(v);
      break;
    }
 
    case ChannelDataType::SignedIntegerLe:
    case ChannelDataType::SignedIntegerBe: {
      int64_t v = 0;
      valid = GetSampleSigned(sample, v, array_index);
      value = static_cast<V>(v);
      break;
    }
 
    case ChannelDataType::FloatLe:
    case ChannelDataType::FloatBe: {
      double v = 0.0;
      valid = GetSampleFloat(sample, v, array_index);
      value = static_cast<V>(v);
      break;
    }
 
    case ChannelDataType::StringAscii:
    case ChannelDataType::StringUTF8:
    case ChannelDataType::StringUTF16Le:
    case ChannelDataType::StringUTF16Be: {
      std::string v;
      valid = GetSampleText(sample, v, array_index);
      std::istringstream s(v);
      s >> value;
      break;
    }
 
    case ChannelDataType::MimeStream:
    case ChannelDataType::MimeSample:
    case ChannelDataType::ByteArray: {
      std::vector<uint8_t> v;
      valid = GetSampleByteArray(sample, v);
      value = static_cast<V>(v.empty() ? V{} : v[0]);
      break;
    }
 
    default:
      break;
  }
  return valid;
}
 
template <>
bool IChannelObserver::GetChannelValue(uint64_t sample,
                                       std::string& value, uint64_t array_index) const;
 
template <>
bool IChannelObserver::GetChannelValue(uint64_t sample,
                                       std::vector<uint8_t>& value, uint64_t array_index) const;
 
template <typename V>
std::vector<bool> IChannelObserver::GetChannelSamples(
    std::vector<V>& values) const {
  const uint64_t nof_samples = NofSamples();
  std::vector<bool> valid_array(nof_samples, false);
  values.resize(nof_samples, {});
  uint64_t sample = 0;
  for (auto& value : values) {
    valid_array[sample] = GetChannelValue(sample, value, 0);
    ++sample;
  }
  return valid_array;
}
 
template <typename V>
std::vector<bool> IChannelObserver::GetChannelValues(uint64_t sample,
                                             std::vector<V>& values) const {
  const auto array_size = ArraySize();
  std::vector<bool> valid_array(array_size, false);
  values.resize(array_size, {});
  uint64_t index = 0;
  for (auto& value : values) {
    valid_array[index] = GetChannelValue(sample, value, index);
    ++index;
  }
  return valid_array;
}
 
template <typename V>
bool IChannelObserver::GetEngValue(uint64_t sample, V& value, uint64_t array_index) const {
  const auto* conversion = channel_.ChannelConversion();
  if (conversion == nullptr) {
    return GetChannelValue(sample, value, array_index);
  }
 
  bool valid = false;
  value = {};
  switch (channel_.DataType()) {
    case ChannelDataType::UnsignedIntegerLe:
    case ChannelDataType::UnsignedIntegerBe: {
      uint64_t v = 0;
      valid = GetSampleUnsigned(sample, v, array_index)
        && conversion->Convert(v, value);
      break;
    }
 
    case ChannelDataType::SignedIntegerLe:
    case ChannelDataType::SignedIntegerBe: {
      int64_t v = 0;
      valid = GetSampleSigned(sample, v, array_index)
        && conversion->Convert(v, value);
      break;
    }
 
    case ChannelDataType::FloatLe:
    case ChannelDataType::FloatBe: {
      double v = 0.0;
      valid = GetSampleFloat(sample, v, array_index)
        && conversion->Convert(v, value);
      break;
    }
 
    case ChannelDataType::StringAscii:
    case ChannelDataType::StringUTF16Be:
    case ChannelDataType::StringUTF16Le:
    case ChannelDataType::StringUTF8: {
      std::string v;
      valid = GetSampleText(sample,  v, array_index);
      std::string temp;
      conversion->Convert(v, temp);
      std::istringstream temp1(temp);
      temp1 >> value;
      break;
    }
 
    default:
      valid = GetChannelValue(sample, value);  // No conversion is allowed;
      break;
  }
  return valid;
}
 
template <>
bool IChannelObserver::GetEngValue(uint64_t sample,
                                       std::vector<uint8_t>& value,
                                       uint64_t array_index) const;
template <typename V>
std::vector<bool> IChannelObserver::GetEngSamples(
    std::vector<V>& values) const {
  const uint64_t nof_samples = NofSamples();
  std::vector<bool> valid_array(nof_samples, false);
  values.resize(nof_samples, {});
  uint64_t sample = 0;
  for (auto& value : values) {
    valid_array[sample] = GetEngValue(sample, value, 0);
    ++sample;
  }
  return valid_array;
}
 
template <typename V>
std::vector<bool> IChannelObserver::GetEngValues(uint64_t sample,
                                                 std::vector<V>& values) const {
  const auto array_size = ArraySize();
  std::vector<bool> valid_array(array_size, false);
  values.resize(array_size, {});
  uint64_t index = 0;
  for (auto& value : values) {
    valid_array[index] = GetEngValue(sample, value, index);
    ++index;
  }
  return valid_array;
}
 
}  // namespace mdf