IHydraNode.h

Go to the documentation of this file.

/** A hydra has N input queues and M output queues each of a specified
 * type.  Not all queues may have elements.  The implementation
 * callable may leave elements in input queues for subsequent calls
 * when new data exists.
 */

#ifndef WIRECELL_IHYDRANODE
#define WIRECELL_IHYDRANODE

#include "WireCellIface/INode.h"
#include "WireCellUtil/TupleHelpers.h"

#include <boost/any.hpp>
#include <vector>
#include <deque>

namespace WireCell {


    /** Base hydra node class.
     *
     */ 
    class IHydraNodeBase : public INode
    {
    public:
        typedef std::shared_ptr<IHydraNodeBase> pointer;

        virtual ~IHydraNodeBase() ;

        typedef std::deque<boost::any> any_queue;
        typedef std::vector< any_queue > any_queue_vector;

        /// The calling signature:
        virtual bool operator()(any_queue_vector& anyinq,
                                any_queue_vector& anyoutq) = 0;

        virtual NodeCategory category() {
            return hydraNode;
        }

        /// By default assume hydra nodes can do their thing stateless.
        virtual int concurrency() { return 0; }


    };

    /** A hydra with input and output fixed at compile-time with tuples.
     */
    template <typename InputTuple, typename OutputTuple>
    class IHydraNode : public IHydraNodeBase {
    public:

        typedef InputTuple input_tuple_type;
        typedef OutputTuple output_tuple_type;

        typedef shared_queued<InputTuple> input_shqed;
        typedef shared_queued<OutputTuple> output_shqed;

        typedef typename input_shqed::shared_queued_tuple_type input_queues_type;
        typedef typename output_shqed::shared_queued_tuple_type output_queues_type;

        virtual ~IHydraNode() {}

        /// Translate call from any to types and back.
        virtual bool operator()(any_queue_vector& anyinq,
                                any_queue_vector& anyoutq) {
            input_shqed ih;
            output_shqed oh;

            auto inq = ih.from_any_queue(anyinq);
            output_queues_type outq;

            bool ok = (*this)(inq, outq);
            if (ok) {
                anyoutq = oh.as_any_queue(outq);
            }

            // (re)set input queue
            anyinq = ih.as_any_queue(inq);
            return ok;
        }

        /// Typed interface for subclass to implement.
        virtual bool operator()(input_queues_type& inqs,
                                output_queues_type& outqs) = 0;

        // Return the names of the types this node takes as input.
        virtual std::vector<std::string>  input_types() {
            tuple_helper<input_tuple_type> ih;
            return ih.type_names();
        }
        // Return the names of the types this node produces as output.
        virtual std::vector<std::string>  output_types() {
            tuple_helper<output_tuple_type> oh;
            return oh.type_names();
        }
        
    };
    
}

#endif