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