teca_threaded_programmable_algorithm.h

#ifndef teca_threaded_programmable_algorithm_h
#define teca_threaded_programmable_algorithm_h
 
#include "teca_metadata.h"
#include "teca_threaded_algorithm.h"
#include "teca_dataset_fwd.h"
 
#include "teca_programmable_algorithm_fwd.h"
 
 
class teca_threaded_programmable_algorithm : public teca_threaded_algorithm
{
public:
    TECA_ALGORITHM_STATIC_NEW(teca_threaded_programmable_algorithm)
    TECA_ALGORITHM_DELETE_COPY_ASSIGN(teca_threaded_programmable_algorithm)
    ~teca_threaded_programmable_algorithm();
 
    // set/get the class name.
    virtual int set_name(const std::string &name);
 
    const char *get_class_name() const override
    { return this->class_name; }
 
    // set the number of input and outputs
    using teca_algorithm::set_number_of_input_connections;
    using teca_algorithm::set_number_of_output_ports;
 
    // set the number of threads. The default is -1. 
    using teca_threaded_algorithm::set_thread_pool_size;
 
    // set the stream size. the default -1 disables streaming.
    // you should set this (2 is a good choice) if your algorithm
    // can stream data.
    using teca_threaded_algorithm::set_stream_size;
 
    // install the default implementation
    void use_default_report_action();
    void use_default_request_action();
    void use_default_execute_action();
 
    // set callback that responds to reporting stage
    // of pipeline execution. the report callback must
    // be callable with signature:
    //
    //   teca_metadata (unsigned int,
    //      const std::vector<teca_metadata> &)
    //
    // the default implementation forwards downstream
    TECA_ALGORITHM_CALLBACK_PROPERTY(
        report_callback_t, report_callback)
 
    // set the callback that responds to the requesting
    // stage of pipeline execution. the request callback
    // must be callable with the signature:
    //
    //  std::vector<teca_metadata> (
    //    unsigned int,
    //    const std::vector<teca_metadata> &,
    //    const teca_metadata &)
    //
    // the default implementation forwards upstream
    TECA_ALGORITHM_CALLBACK_PROPERTY(
        request_callback_t, request_callback)
 
    // set the callback that responds to the execution stage
    // of pipeline execution. the execute callback must be
    // callable with the signature:
    //
    //  const_p_teca_dataset (
    //    unsigned int, const std::vector<const_p_teca_dataset> &,
    //    const teca_metadata &, int)
    //
    // the default implementation returns a nullptr
    TECA_ALGORITHM_CALLBACK_PROPERTY(
        threaded_execute_callback_t, execute_callback)
 
protected:
    teca_threaded_programmable_algorithm();
 
private:
    teca_metadata get_output_metadata(unsigned int port,
        const std::vector<teca_metadata> &input_md) override;
 
    std::vector<teca_metadata> get_upstream_request(
        unsigned int port,
        const std::vector<teca_metadata> &input_md,
        const teca_metadata &request) override;
 
    const_p_teca_dataset execute(unsigned int port,
        const std::vector<const_p_teca_dataset> &input_data,
        const teca_metadata &request, int streaming) override;
 
protected:
    report_callback_t report_callback;
    request_callback_t request_callback;
    threaded_execute_callback_t execute_callback;
    char class_name[64];
};
 
#endif