reader.h

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <memory>
#include <vector>
#include <unordered_map>
#include <istream>
#include <string>
#include <optional>
#include <ifhd/ifhd.h>
#include "stream_item.h"
#include "object.h"
#include "default_sample.h"
#include "stream_type.h"
#include "configuration.h"
 
namespace adtf_file
{
namespace exceptions
{
using ifhd::exceptions::EndOfFile;

class SeekingNotSupported : public std::runtime_error
{
public:
    SeekingNotSupported(): runtime_error("Seeking is not supported")
    {
    }
 
    using std::runtime_error::runtime_error;
};
 
} // namespace exceptions

class Extension
{
public:
    std::string name;
    uint16_t stream_id;
    uint32_t user_id;
    uint32_t type_id;
    uint32_t version_id;
    size_t data_size;
    const void* data;
};

class StreamTypeFactory
{
public:
    virtual std::shared_ptr<StreamType> build() const = 0;
};

template<typename STREAM_TYPE_CLASS>
class stream_type_factory : public StreamTypeFactory
{
public:
    std::shared_ptr<StreamType> build() const override
    {
        return std::make_shared<STREAM_TYPE_CLASS>();
    }
};

class SampleFactory
{
public:
    virtual std::shared_ptr<Sample> build() const = 0;
};

template<typename SAMPLE_CLASS>
class sample_factory : public SampleFactory
{
public:
    std::shared_ptr<Sample> build() const override
    {
        return std::make_shared<SAMPLE_CLASS>();
    }
};

class Stream
{
public:
    uint16_t stream_id;
    std::string name;
    uint64_t item_count;
    std::chrono::nanoseconds timestamp_of_first_item;
    std::chrono::nanoseconds timestamp_of_last_item;
    std::shared_ptr<const StreamType> initial_type;
};

class FileItem
{
public:
    uint16_t stream_id;
    std::chrono::nanoseconds time_stamp;
    std::shared_ptr<const StreamItem> stream_item;
};

class Reader : public Configurable
{
public:
    virtual std::string getReaderIdentifier() const = 0;

    virtual void open(const std::string& filename,
                      std::shared_ptr<SampleFactory> sample_factory,
                      std::shared_ptr<StreamTypeFactory> stream_type_factory) = 0;

    virtual FileItem getNextItem() = 0;

    virtual uint32_t getFileVersion() const
    {
        return ifhd::v201_v301::version_id;
    }

    virtual std::string getDescription() const
    {
        return {};
    }

    virtual std::vector<Extension> getExtensions() const
    {
        return {};
    }

    virtual std::vector<Stream> getStreams() const
    {
        return {};
    }

    virtual std::optional<uint64_t> getItemCount() const
    {
        return {};
    }

    virtual std::optional<double> getProgress() const
    {
        return {};
    }
};

class SeekableReader : public Reader
{
public:
    virtual uint64_t getItemIndexForTimeStamp(std::chrono::nanoseconds time_stamp) = 0;

    virtual uint64_t getItemIndexForStreamItemIndex(uint16_t stream_id, uint64_t stream_item_index) = 0;

    virtual std::shared_ptr<const StreamType> getStreamTypeBefore(uint64_t item_index, uint16_t stream_id) = 0;

    virtual void seekTo(uint64_t item_index) = 0;
};

class ExplicitReader
{
};

class ReaderFactory : public Object
{
public:
    virtual std::shared_ptr<Reader> makeReader() const = 0;
};

template<typename T>
class ReaderFactoryImplementation : public ReaderFactory
{
public:
    std::shared_ptr<adtf_file::Reader> makeReader() const override
    {
        return std::make_shared<T>();
    }
};

class ReaderFactories
{
public:
    void add(const std::shared_ptr<const adtf_file::ReaderFactory>& factory);

    void remove(const std::string& reader_id);

    std::shared_ptr<adtf_file::Reader> makeReader(const std::string& reader_id) const;

    std::shared_ptr<adtf_file::Reader>
        openReader(const std::string& filename,
                   const adtf_file::Configuration& configuration = {},
                   std::shared_ptr<adtf_file::SampleFactory> sample_factory = {},
                   std::shared_ptr<adtf_file::StreamTypeFactory> stream_type_factory = {},
                   std::optional<std::string> reader_id = {}) const;

    void getCapableReaders(const std::string& filename,
                           const std::function<bool(const std::shared_ptr<Reader>&)>& capable_reader_callback,
                           const adtf_file::Configuration& configuration = {},
                           std::shared_ptr<adtf_file::SampleFactory> sample_factory = {},
                           std::shared_ptr<adtf_file::StreamTypeFactory> stream_type_factory = {}) const;

    const std::unordered_map<std::string, std::shared_ptr<const ReaderFactory>>& getFactories() const;
 
private:
    std::unordered_map<std::string, std::shared_ptr<const ReaderFactory>> _factories;
};

Stream findStream(const Reader& reader, const std::string& stream_name);

std::chrono::nanoseconds getFirstTimeOfStreams(const std::vector<Stream>& streams);

std::chrono::nanoseconds getLastTimeOfStreams(const std::vector<Stream>& streams);

ReaderFactories getReaderFactories();
} // namespace adtf_file