adtf_file_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 "reader.h"
 
namespace adtf_file
{
 
class InputStream
{
    public:
        virtual void read(void* destination, size_t count) = 0;
 
        template <typename T>
        InputStream& operator >>(T& value)
        {
            static_assert(std::is_trivially_copyable<T>::value, "Only trivially copyable types and std::string are allowed. Alternatively, provide a specialization for adtf_file::InputStream& operator>>(T& value).");
            read(&value, sizeof(T));
            return *this;
        }
};
 
template <>
InputStream& InputStream::operator>>(std::string& value);
 
class StreamTypeDeserializer: public Object
{
    public:
        virtual std::string getId() const = 0;
        virtual void deserialize(InputStream& stream, PropertyStreamType& stream_type) const = 0;
};
 
class StreamTypeDeserializers: private std::unordered_map<std::string, std::shared_ptr<StreamTypeDeserializer>>
{
    public:
        StreamTypeDeserializers() = default;
        StreamTypeDeserializers& add(const std::shared_ptr<StreamTypeDeserializer>& deserializer)
        {
            (*this)[deserializer->getId()] = deserializer;
            return *this;
        }
 
        void Deserialize(const std::string& id, InputStream& stream, PropertyStreamType& stream_type) const
        {
            auto deserializer = find(id);
            if (deserializer == end())
            {
                throw std::runtime_error("no type deserializer for '" + id + "' available");
            }
 
            deserializer->second->deserialize(stream, stream_type);
        }
};
 
class SampleDeserializer
{
    public:
        virtual void setStreamType(const StreamType& type) = 0;
        virtual void deserialize(ReadSample& sample, InputStream& stream) = 0;
};
 
class SampleDeserializerFactory: public Object
{
    public:
        virtual std::string getId() const = 0;
        virtual std::shared_ptr<SampleDeserializer> build() const = 0;
};
 
template <typename FACTORY>
class sample_deserializer_factory: public SampleDeserializerFactory
{
    public:
        std::string getId() const override
        {
            return FACTORY::id;
        }
 
        std::shared_ptr<SampleDeserializer> build() const override
        {
            return std::make_shared<FACTORY>();
        }
};
 
class SampleDeserializerFactories:
    private std::unordered_map<std::string, std::shared_ptr<SampleDeserializerFactory>>
{
    public:
        SampleDeserializerFactories& add(const std::shared_ptr<SampleDeserializerFactory>& factory)
        {
            (*this)[factory->getId()] = factory;
            return *this;
        }
 
        std::shared_ptr<SampleDeserializer> build(const std::string& id) const
        {
            try
            {
                return at(id)->build();
            }
            catch (...)
            {
                throw std::runtime_error("no sample deserializer factory for '" + id + "' available");
            }
        }
};
 
class ADTFDatFileReader: public SeekableReader
{
    public:
        static constexpr int64_t read_cache_default = -1;
        static constexpr int64_t read_cache_deactivated = 0;
 
        ADTFDatFileReader();
 
        ADTFDatFileReader(std::optional<StreamTypeDeserializers> type_factories,
                          std::optional<SampleDeserializerFactories> sample_deserializer_factories);
 
        ADTFDatFileReader(const ADTFDatFileReader&) = delete;
        
        ADTFDatFileReader(ADTFDatFileReader&&) = default;
 
        // implement Reader interface
        std::string getReaderIdentifier() const override
        {
            return "adtfdat";
        }
 
        void open(const std::string& filename,
                  std::shared_ptr<SampleFactory> sample_factory,
                  std::shared_ptr<StreamTypeFactory> stream_type_factory) override;
 
        void open(const std::string& filename);
 
        FileItem getNextItem() override;
        uint32_t getFileVersion() const override;
        std::string getDescription() const  override;
        std::vector<Extension> getExtensions() const override;
        std::vector<Stream> getStreams() const override;
        std::optional<uint64_t> getItemCount() const override;
        std::optional<double> getProgress() const override;
 
        // implement SeekableReader interface
        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 StreamType> getStreamTypeBefore(uint64_t item_index, uint16_t stream_id) override;
        void seekTo(uint64_t item_index) override;
 
        int64_t getNextItemIndex() const;
 
        a_util::datetime::DateTime getDateTime() const;
        
        std::chrono::nanoseconds getFirstTime() const;
        std::chrono::nanoseconds getLastTime() const;
 
    private:
        void openDescription(const std::string& description_file_name, bool ignore_unsupported_streams);
        std::shared_ptr<const StreamType> buildType(const std::string& id, InputStream& stream);
        std::pair<std::shared_ptr<const StreamType>, std::shared_ptr<SampleDeserializer>> getInitialTypeAndSampleDeserializer(uint16_t stream_id);
        std::pair<std::shared_ptr<const StreamType>, std::shared_ptr<SampleDeserializer> > getInitialTypeAndSampleFactoryAdtf2(InputStream& stream);
        std::pair<std::shared_ptr<const StreamType>, std::shared_ptr<SampleDeserializer>> getInitialTypeAndSampleFactoryAdtf3(InputStream& stream);
        std::chrono::nanoseconds fromFileTimeStamp(timestamp_t time_stamp);
        timestamp_t toFileTimeStamp(std::chrono::nanoseconds time_stamp);
 
    private:
        std::unique_ptr<ifhd::v500::IndexedFileReader> _file;
        std::vector<Extension> _extensions;
        std::vector<Stream> _streams;
        StreamTypeDeserializers _type_factories;
        SampleDeserializerFactories _sample_deserializer_factories;
        std::unordered_map<size_t, std::shared_ptr<SampleDeserializer>> _stream_sample_deserializers;
        std::shared_ptr<SampleFactory> _sample_factory;
        std::shared_ptr<StreamTypeFactory> _stream_type_factory;
};
 
class ADTFDatFileReaderFactory: public ReaderFactory
{
public:
    ADTFDatFileReaderFactory(std::optional<StreamTypeDeserializers> type_factories = {},
                             std::optional<SampleDeserializerFactories> sample_deserializer_factories = {}) :
          _type_factories(type_factories),
          _sample_deserializer_factories(sample_deserializer_factories)
    {
    }
 
    std::shared_ptr<Reader> makeReader() const override
    {
        return std::make_unique<ADTFDatFileReader>(_type_factories,
                                                   _sample_deserializer_factories);
    }
 
private:
    std::optional<StreamTypeDeserializers> _type_factories;
    std::optional<SampleDeserializerFactories> _sample_deserializer_factories;
};
 
inline std::string getShortDescription(const std::string& description)
{
    return description.substr(0, description.find_first_of("\n"));
}
 
inline std::string getLongDescription(const std::string& description)
{
    size_t pos_found = description.find_first_of("\n");
    if (pos_found != std::string::npos)
    {
        return description.substr(pos_found);
    }
    else
    {
        return std::string("");
    }
}
 
}