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 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();
}