AndroMeta/include/AndroMeta/MProc.h

Go to the documentation of this file.

/*
 * Copyright 2009-2012 AndroMeta LLC. All rights reserved.
 *
 * AndroMeta LLC retains all intellectual property and proprietary 
 * rights to this software and related documentation and any modifications 
 * thereto.  Any use, reproduction, disclosure, or distribution of this 
 * software and related documentation without an express license agreement 
 * from AndroMeta LLC is strictly prohibited.
 * 
 */

#ifndef ANDROMETA_M_PROC_H
#define ANDROMETA_M_PROC_H

#include <AndroMeta/MTime.h>

namespace Meta{
  
  class MProcTask;
  
  class MProc{
  public:
    
    typedef MMap<int, mvar> SignalMap;
    typedef MVector<int> IdVec;
    
    MProc();
    
    virtual ~MProc();
    
    void queue(MProcTask* task,
               MProc::SignalMap* signalMap=0,
               double priority=0,
               bool activate=false,
               const mtime* time=0);
    
    virtual bool activate(SignalMap& signalMap);
    
    virtual mvar run(SignalMap& signalMap);
    
    void run(SignalMap* signalMap);
    
    virtual int connect(MProc* mp, const mvar& data=undef);
    
    virtual void connect(int outId,
                         int inId,
                         MProc* mp,
                         const mvar& data=undef);
    
    virtual void disconnect(int outId);
    
    virtual void disconnect();
    
    virtual void detach();
    
    virtual void signal(int outId);
    
    virtual void signal(int outId, const mvar& v);
    
    virtual void signal(int outId,
                        const mvar& v,
                        double priority,
                        bool persist=true,
                        const mtime* time=0);
    
    virtual void signalAll();
    
    virtual void signalAll(const mvar& v);
    
    virtual void signalAll(const mvar& v,
                           double priority,
                           bool persist=true,
                           const mtime* time=0);
    
    const IdVec& outEdges() const;
    
    const IdVec& inEdges() const;
    
    bool isThreaded() const;
    
    void setThreaded(bool flag);
    
    bool terminate(bool block=true);
    
    bool hasTerminated() const;
    
    void reset();
    
    MProc* outEdge(int outId);
    
    MProc* inEdge(int inId);
    
    const MProc* outEdge(int outId) const;
    
    const MProc* inEdge(int inId) const;
    
    int inId(int outId) const;
 
    int outId(int inId) const;
    
    const mvar& edgeData(int outId) const;
    
    void setEdgeData(int outId, const mvar& v);
    
  private:
    MProc& operator=(const MProc&);
    MProc(const MProc&);
    
    class MProc_* x_;
  };
  
} // end namespace Meta

#endif // ANDROMETA_M_PROC_H