mdfreader.h

/*
 * Copyright 2021 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
#include <cstdio>
#include <memory>
#include <string>
#include <functional>
#include <vector>
 
#include "mdf/ichannelobserver.h"
#include "mdf/mdffile.h"
#include "mdf/isamplereduction.h"
 
namespace mdf {
 
class IChannelGroup;
 
using ChannelObserverPtr = std::unique_ptr<IChannelObserver>;
using ChannelObserverList = std::vector<ChannelObserverPtr>;
 
[[nodiscard]] bool IsMdfFile(const std::string& filename);
 
[[nodiscard]] ChannelObserverPtr CreateChannelObserver(
    const IDataGroup& data_group, const IChannelGroup& group,
    const IChannel& channel);
[[nodiscard]] ChannelObserverPtr CreateChannelObserver(
    const IDataGroup& dg_group, const std::string& channel_name);
 
void CreateChannelObserverForChannelGroup(const IDataGroup& data_group,
                                          const IChannelGroup& group,
                                          ChannelObserverList& dest);
 
void CreateChannelObserverForDataGroup(const IDataGroup& data_group,
                                          ChannelObserverList& dest_list);
class MdfReader {
 public:
  explicit MdfReader(
      const std::string& filename);  
  virtual ~MdfReader();  
 
  MdfReader() = delete;
  MdfReader(const MdfReader&) = delete;
  MdfReader(MdfReader&&) = delete;
  MdfReader& operator=(const MdfReader&) = delete;
  MdfReader& operator=(MdfReader&&) = delete;
 
  [[nodiscard]] int64_t Index() const { return index_; }
 
  void Index(int64_t index) { index_ = index; }
 
  [[nodiscard]] bool IsOk() const { return static_cast<bool>(instance_); }
 
  [[nodiscard]] bool IsFinalized() const;
 
  [[nodiscard]] const MdfFile* GetFile() const { return instance_.get(); }
 
  [[nodiscard]] const IHeader* GetHeader() const;
  [[nodiscard]] IDataGroup* GetDataGroup(size_t order) const;
 
  [[nodiscard]] std::string ShortName()
      const;  
 
  bool Open();   
  void Close();  
 
  bool ReadHeader();             
  bool ReadMeasurementInfo();    
  bool ReadEverythingButData();  
 
  bool ExportAttachmentData(const IAttachment& attachment,
                            const std::string& dest_file);
 
  bool ReadData(IDataGroup& data_group);
 
  bool ReadPartialData(IDataGroup& data_group, size_t min_sample,
                       size_t max_sample);
 
  bool ReadSrData(ISampleReduction& sr_group);
 
  bool ReadVlsdData(IDataGroup &data_group,
                    IChannel &vlsd_channel,
                    const std::vector<uint64_t>& offset_list,
                    std::function<void(uint64_t,
                                       const std::vector<uint8_t>&)>& callback);
 
 
 private:
  std::FILE* file_ = nullptr;          
  std::string filename_;               
  std::unique_ptr<MdfFile> instance_;  
  int64_t index_ = 0;  
};
 
}  // namespace mdf