default_sample.h

Go to the documentation of this file.

 
#ifndef ADTF_FILE_DEFAULT_SAMPLE
#define ADTF_FILE_DEFAULT_SAMPLE
 
#include "stream_item.h"
#include "sample.h"
 
#include <vector>
#include <chrono>
#include <cstring>
#include <functional>
#include <unordered_map>
#include <vector>
#include <variant>
#include <stdexcept>
 
namespace adtf_file
{

class DefaultSample: public Sample, public ReadSample, public WriteSample, public SampleCopy
{
    public:
        void setTimeStamp(std::chrono::nanoseconds time_stamp) override;
        void setSubStreamId(uint32_t substream_id) override;
        void setFlags(uint32_t flags) override;
        void* beginBufferWrite(size_t size) override;
        void endBufferWrite() override;
        void addInfo(uint32_t key, DataType type, uint64_t raw_bytes) override;
 
    public:
        std::chrono::nanoseconds getTimeStamp() const override;
        uint32_t getSubStreamId() const override;
        uint32_t getFlags() const override;
        std::pair<const void*, size_t> beginBufferRead() const override;
        void endBufferRead() const override;
        void iterateInfo(std::function<void(uint32_t key, DataType type, uint64_t raw_bytes)> functor) const override;
 
    public:
        void CopyFrom(const std::shared_ptr<const Sample>& sample) override;
 
    public:
        const std::unordered_map<uint32_t, std::pair<DataType, uint64_t>>& GetInfo() const;
 
    public:
        template <typename T>
        void setContent(const T& value)
        {
            static_assert(std::is_trivially_copyable<T>::value, "Only trivially copyable types are allowed.");
            const auto buffer = beginBufferWrite(sizeof(value));
            std::memcpy(buffer, &value, sizeof(value));
            endBufferWrite();
        }

        template <typename T>
        T getContent() const
        {
            static_assert(std::is_trivially_copyable<T>::value, "Only trivially copyable types are allowed.");
            const auto [buffer, buffer_size] = beginBufferRead();
            if (sizeof(T) > buffer_size)
            {
                endBufferRead();
                throw std::runtime_error("invalid sample size for requested type");
            }
            const auto value = *reinterpret_cast<const T*>(buffer);
            endBufferRead();
            return value;
        }
 
    private:
        std::chrono::nanoseconds _time_stamp = std::chrono::nanoseconds(0);
        uint32_t _substream_id = 0;
        uint32_t _flags = 0;
        std::variant<std::monostate, std::vector<uint8_t>, std::shared_ptr<const WriteSample>> _buffer;
        std::unordered_map<uint32_t, std::pair<DataType, uint64_t>> _info;
};
 
}
 
#endif