multiplexer.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <functional>
#include <unordered_map>
 
#include <adtf_file/adtf_file_writer.h>
#include <adtf_file/reader.h>
 
namespace adtfdat_processing
{

class OffsetReaderWrapper : public adtf_file::Reader
{
public:
    OffsetReaderWrapper(const std::shared_ptr<Reader> original_reader,
                        std::chrono::nanoseconds offset,
                        std::chrono::nanoseconds start_offset,
                        std::chrono::nanoseconds end_offset);
 
    std::string getReaderIdentifier() const override;
    uint32_t getFileVersion() const override;
    std::string getDescription() const override;
 
    void open(const std::string& filename,
              std::shared_ptr<adtf_file::SampleFactory> sample_factory,
              std::shared_ptr<adtf_file::StreamTypeFactory> stream_type_factory) override;
 
    void setConfiguration(const adtf_file::Configuration& configuration) override;
    const adtf_file::Configuration& getConfiguration() const override;
 
    std::vector<adtf_file::Extension> getExtensions() const override;
    std::vector<adtf_file::Stream> getStreams() const override;
 
    adtf_file::FileItem getNextItem() override;
    std::optional<uint64_t> getItemCount() const override;
    std::optional<double> getProgress() const override;
 
private:
    std::shared_ptr<Reader> _original_reader;
    std::chrono::nanoseconds _offset;
    std::chrono::nanoseconds _start_offset;
    std::chrono::nanoseconds _end_offset;
 
    adtf_file::FileItem _next_item;
    std::unordered_map<uint16_t, std::shared_ptr<const adtf_file::StreamItem>> _last_stream_types;
};

class Multiplexer
{
public:
    Multiplexer(const std::string& destination_file_name,
                adtf_file::ADTFDatFileWriter::TargetADTFVersion target_adtf_version =
                    adtf_file::ADTFDatFileWriter::TargetADTFVersion::adtf3ns,
                bool skip_stream_types_and_triggers = false,
                bool store_checksums = false);

    void addStream(const std::shared_ptr<adtf_file::Reader> reader,
                   const std::string& stream_name,
                   const std::string& destination_stream_name,
                   const std::shared_ptr<adtf_file::SampleSerializer> serializer);

    void addExtension(const std::string& name,
                      const void* extension_data,
                      size_t extension_size,
                      uint32_t user_id = 0,
                      uint32_t type_id = 0,
                      uint32_t version_id = 0);

    void process(const std::function<bool(double)>& progress_handler);
 
private:
    std::optional<double> calculateProgress();
 
private:
    adtf_file::ADTFDatFileWriter _writer;
    bool _skip_stream_types_and_triggers;
    std::unordered_map<std::shared_ptr<adtf_file::Reader>, std::unordered_map<uint16_t, size_t>>
        _stream_mapping;
};
}