isampleobserver.h

Go to the documentation of this file.

/*
 * Copyright 2021 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
#include <cstdint>
#include <vector>
#include <set>
#include <functional>
 
#include "mdf/ichannelgroup.h"
#include "mdf/idatagroup.h"
namespace mdf {
 
 
 
class ISampleObserver {
 public:
  ISampleObserver() = delete;
 
  explicit ISampleObserver(const IDataGroup& data_group);
 
  virtual ~ISampleObserver(); 
 
  virtual void AttachObserver();
 
  virtual void DetachObserver();
 
  virtual bool OnSample(uint64_t sample, uint64_t record_id,
                        const std::vector<uint8_t>& record);
 
  [[nodiscard]] bool IsRecordIdNeeded(uint64_t record_id) const {
    return record_id_list_.find(record_id) != record_id_list_.cend();
  }
 
  std::function<bool(uint64_t sample, uint64_t record_id,
      const std::vector<uint8_t>& record)> DoOnSample;
 
  template <typename V>
  bool GetChannelValue(const IChannel& channel,
      uint64_t sample,
      const std::vector<uint8_t>& record,
      V& value,
      uint64_t array_index = 0) const {
    bool valid = false;
    value = {};
 
    switch (channel.Type()) {
      case ChannelType::VirtualMaster:
      case ChannelType::VirtualData:
        valid = channel.GetVirtualSample(sample, value);
        break;
 
        // This channel may reference a SD/CG blocks
      case ChannelType::VariableLength:
        if (channel.VlsdRecordId() == 0) {
          // If variable length, the value is an index into an SD block.
          // Value should be in the channels data list (SD). The channels
          // GetChannelValue handle this situation
          valid = channel.GetChannelValue(record, value, array_index);
        }
        // VLSD CG records cannot be handled without some sort of cache.
        break;
 
      case ChannelType::MaxLength:
      case ChannelType::Sync:
      case ChannelType::Master:
      case ChannelType::FixedLength:
      default:
        valid = channel.GetChannelValue(record, value, array_index);
        break;
    }
    return valid;
  }
 
  template <typename V>
  bool GetEngValue(const IChannel& channel,
      uint64_t sample,
      const std::vector<uint8_t>& record,
      V& value,
      uint64_t array_index = 0) const {
 
    const auto* conversion = channel.ChannelConversion();
    if (conversion == nullptr) {
      return GetChannelValue(channel,sample, record,
          value, array_index);
    }
 
    bool valid;
    value = {};
    switch (channel.DataType()) {
      case ChannelDataType::UnsignedIntegerLe:
      case ChannelDataType::UnsignedIntegerBe: {
        uint64_t v = 0;
        valid = GetChannelValue(channel,sample,  record, v,
          array_index) && conversion->Convert(v, value);
        break;
      }
 
      case ChannelDataType::SignedIntegerLe:
      case ChannelDataType::SignedIntegerBe: {
        int64_t v = 0;
        valid = GetChannelValue(channel,sample,  record, v,
          array_index) && conversion->Convert(v, value);
        break;
      }
 
      case ChannelDataType::FloatLe:
      case ChannelDataType::FloatBe: {
        double v = 0.0;
        valid = GetChannelValue(channel,sample,  record, v,
          array_index) && conversion->Convert(v, value);
        break;
      }
 
      case ChannelDataType::StringAscii:
      case ChannelDataType::StringUTF16Be:
      case ChannelDataType::StringUTF16Le:
      case ChannelDataType::StringUTF8: {
        std::string v;
        valid = GetChannelValue(channel,sample,  record, v,
          array_index) && conversion->Convert(v, value);
        break;
      }
 
      default:
        valid = GetChannelValue(channel,sample,  record, value,
          array_index);
        break;
    }
    return valid;
  }
 
 protected:
  std::set<uint64_t> record_id_list_; 
  const IDataGroup& data_group_;  
 private:
  bool attached_ = false; 
};
 
 
 
}  // namespace mdf