streams_to_substreams_reader.h

Go to the documentation of this file.

 
#pragma once
#include <adtf_file/reader.h>
#include <variant>
 
namespace adtfdat_processing
{

class StreamsToSubstreamsReader: public adtf_file::SeekableReader,
                                 public adtf_file::ExplicitReader
{
public:
    StreamsToSubstreamsReader();
 
    std::string getReaderIdentifier() const override;
    void open(const std::string& file_name,
              std::shared_ptr<adtf_file::SampleFactory> sample_factory,
              std::shared_ptr<adtf_file::StreamTypeFactory> stream_type_factory) override;
 
    uint32_t getFileVersion() const override;
    std::string getDescription() const override;
    std::vector<adtf_file::Stream> getStreams() const override;
    std::vector<adtf_file::Extension> getExtensions() const override;
    adtf_file::FileItem getNextItem() override;
    std::optional<uint64_t> getItemCount() const override;
    std::optional<double> getProgress() const override;
 
    uint64_t getItemIndexForTimeStamp(std::chrono::nanoseconds time_stamp) override;
    uint64_t getItemIndexForStreamItemIndex(uint16_t stream_id, uint64_t stream_item_index) override;
    std::shared_ptr<const adtf_file::StreamType> getStreamTypeBefore(uint64_t item_index, uint16_t stream_id) override;
    void seekTo(uint64_t item_index) override;
 
private:
    std::shared_ptr<adtf_file::SampleFactory> _sample_factory;
    std::shared_ptr<adtf_file::StreamTypeFactory> _stream_type_factory;
    std::shared_ptr<Reader> _reader;
    adtf_file::Stream _stream;
 
    struct SourceStream
    {
        std::string name;
        std::shared_ptr<const adtf_file::PropertyStreamType> type;
 
        bool operator==(const SourceStream& other) const
        {
            return name == other.name && type == other.type;
        }
    };
    using SourceStreams = std::unordered_map<uint16_t, SourceStream>;
    using SubstreamIDs = std::unordered_map<uint16_t, std::variant<uint32_t, std::unordered_map<uint32_t, uint32_t>>>;
 
    struct MappedStreams
    {
        std::shared_ptr<adtf_file::StreamType> type;
        SubstreamIDs substream_ids;
    };
    MappedStreams buildMap(const SourceStreams& streams) const;
 
    struct Substreams
    {
        Substreams() = default;
        Substreams(SourceStreams source_streams,
                   MappedStreams stream_map):
            source_streams(std::move(source_streams)),
            stream_map(std::move(stream_map))
        {
        }
        SourceStreams source_streams;
        MappedStreams stream_map;
    };
    const Substreams& buildCache(uint64_t item_index);
    std::unordered_map<uint64_t, Substreams> _seek_cache;
 
    Substreams _current_substreams;
};

using StreamsToSubstreamsReaderFactory = adtf_file::ReaderFactoryImplementation<StreamsToSubstreamsReader>;
 
}