processor.h

Go to the documentation of this file.

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

class Processor : public adtf_file::Configurable
{
public:
    virtual std::string getProcessorIdentifier() const = 0;

    virtual bool isCompatible(const adtf_file::Stream& stream) const = 0;

    virtual void open(const std::vector<adtf_file::Stream>& streams, const std::string& destination_url) = 0;

    virtual void process(const adtf_file::FileItem& item) = 0;
};

class SingleStreamProcessor : public Processor
{
public:

    void open(const std::vector<adtf_file::Stream>& streams, const std::string& destination_url) override
    {
        if (streams.size() != 1)
        {
            throw std::runtime_error("processor '" + getProcessorIdentifier() + "' supports a single input stream only. Open was called with " + std::to_string(streams.size()) + " streams.");
        }
        open(streams.front(), destination_url);
    }

    virtual void open(const adtf_file::Stream& stream, const std::string& destination_url) = 0;
};
 

class ProcessorFactory : public adtf_file::Object
{
public:
    virtual std::shared_ptr<Processor> makeProcessor() const = 0;
};

template <typename PROCESSOR_CLASS>
class ProcessorFactoryImplementation : public ProcessorFactory
{
public:
    std::shared_ptr<Processor> makeProcessor() const override
    {
        return std::make_shared<PROCESSOR_CLASS>();
    }
};

class ProcessorFactories
{
public:
    void add(const std::shared_ptr<const ProcessorFactory>& factory)
    {
        auto processor = factory->makeProcessor();
        _factories[processor->getProcessorIdentifier()] = factory;
    }

    std::shared_ptr<Processor> makeProcessor(const std::string& processor_id) const
    {
        auto factory = _factories.find(processor_id);
        if (factory == _factories.end())
        {
            throw std::runtime_error("no factory for processor " + processor_id);
        }
 
        return factory->second->makeProcessor();
    }

    void getCapableProcessors(const adtf_file::Stream& stream,
        const std::function<bool(const std::shared_ptr<Processor>&)> callback_processor,
        const adtf_file::Configuration& configuration = {}) const
    {
        for (auto& factory : _factories)
        {
            const auto processor = factory.second->makeProcessor();
            processor->setConfiguration(configuration);
            if (processor->isCompatible(stream))
            {
                if (!callback_processor(processor))
                {
                    break;
                }
            }
        }
    }

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

namespace meta_info
{

class DefaultFilenameExtension : public adtf_file::Configuration
{
public:
    explicit DefaultFilenameExtension(std::string default_filename_extension):
        adtf_file::Configuration{{adtf_file::detail::ReservedProperties::default_filename_extension,
                       adtf_file::PropertyValue{std::move(default_filename_extension)}}}
    {
    }
};
 
}
 
}