lib/controller.h

#ifndef __CONTROLLER_H__
#define __CONTROLLER_H__

#include <stdint.h>

#include <map>
#include <set>
#include <list>
#include <utility>
#include <string>

#include "threadutils.h"
#include "scheduler.h"
#include "modules.h"
#include "processthread.h"

#ifdef LoadImage
#undef LoadImage
#endif

// Forward declarations
namespace spectral
{
    class Image;
    class Parameters;
}

namespace control
{
    class ProcessThread;
}

// Class definitions
namespace control 
{

// Information about a node in the dependency graph.  Includes output type,
// allowed input types, links and parameters.
class NodeData
{
public:
    NodeData();
    NodeData(const NodeData &);
    NodeData(spectral::Processor *);
    ~NodeData();
    const NodeData & operator=(const NodeData &other);

    uint32_t GetIO(std::list<std::pair<uint32_t, uint32_t> >&,
                   std::list<std::pair<uint32_t, uint32_t> >&) const;

    spectral::Parameters *GetParameters(void) const;
    void SetParameters(spectral::Parameters *);

    const std::map<uint32_t, int32_t>& GetInputs(void) const;

    uint32_t GetInputType(uint32_t slot);
    int32_t GetInputID(uint32_t slot);
    
    void LinkInput(uint32_t slot, int32_t id);
    void UnlinkInput(int32_t id);
    bool HasLink(int32_t id);

private:
    uint32_t                                  m_outputType;
    std::list<std::pair<uint32_t, uint32_t> > m_mandatory;
    std::list<std::pair<uint32_t, uint32_t> > m_optional;
    spectral::Parameters                     *m_parameters;
    std::map<uint32_t, int32_t>               m_inputs;
};

// Controller thread class.  Decides what needs to be run and when.
// All external interfaces should be asynchronous, so as to eliminate the need
// for locking within the class itself.
class STM_EXPORT Controller : public thread::Thread
{
public:
    Controller(const std::string &modulePath,
               const std::list<std::string> &modules);
    virtual ~Controller();

    void LoadImage(const std::string &fn);
    void LoadImage(int32_t id, const std::string &fn);
    void SaveImage(int32_t id, const std::string &fn);
    void Process(void);
    void Shutdown(void);

    void AddActor(int32_t id, std::string name);
    void RemoveActor(int32_t id);
    void AddLink(int32_t id, uint32_t slot, int32_t input_id);

    void RequestParameters(int32_t id);
    void RequestImage(int32_t id);

    void SetParameters(int32_t id, spectral::Parameters *params);

    MessageQueue &GetOutputQueue(void) {return m_output;}
protected:
    virtual void *MainLoop(void);
private:
    //
    // Utilities
    //

    // Load a set of modules.
    void LoadModules(const std::list<std::string> &);

    // Schedule processing and generate results.
    void ProcessImage(void);
    bool StartNextProcess(void);

    // Utilities for dealing with outputs from processors.
    void _EraseImage(int32_t);
    uint32_t _SetImage(int32_t, spectral::Image *);
    spectral::Image *_GetImage(int32_t);
    uint32_t _GetImageSeq(int32_t);
    void _RemoveActor(int32_t);

    // Get the next image sequence number.
    uint32_t _GetSeqNumber(void);

    // Rebuild the schedulers dependencies from scratch.
    void _RebuildDependencies(void);

    void Stop(void);

    //
    // Message handlers.
    //
    // These mainly exist to cut down some ludicrously large switch statements.
    //
    void OnMsgSetActor(int32_t id, std::string &name);
    void OnMsgSetInput(int32_t id, std::pair<uint32_t, int32_t> link);
    void OnMsgLoadImage(int32_t id, spectral::Image *img);
    void OnMsgSaveImage(int32_t id, const std::string &fn);
    void OnMsgResult(int32_t id, spectral::Image *img, bool &terminate);

    //
    // Data types
    //

    // Module handling.
    spectral::Modules                        m_moduleLoader;
    std::string                              m_modulePath;

    // Dependency support.
    std::map<int32_t, NodeData>              m_graph;
    Scheduler                                m_scheduler;

    // Result images.
    std::map<int32_t, std::pair<uint32_t, spectral::Image*> > m_images;

    // Processor threads.
    std::map<int32_t, ProcessThread*>        m_actors;

    // Message queues.
    MessageQueue                             m_queue;
    MessageQueue                             m_output;
    uint32_t m_sequenceNumber;
};

}

#endif

---