AndroMeta/include/AndroMeta/MMLEntity.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_MML_ENTITY_H
#define ANDROMETA_MML_ENTITY_H

#include <AndroMeta/MObject.h>
#include <AndroMeta/MTime.h>
#include <AndroMeta/MVar.h>
#include <AndroMeta/MProc.h>
#include <AndroMeta/MNode.h>

namespace Meta{
  
  class MProcTask;
  class MMessageBuffer;
  class MMLRoot;
  
  class MMLEntity : public MObject{
  public:
    
    static const ClassIdType ClassId;
    
    MMLEntity();
    
    MMLEntity(int id);
    
    MMLEntity(const MMLEntity& entity, bool recursive=false); 
    
    MMLEntity(const mvar& v, RestoreOpt opt, MMLRoot* root=0);
    
    MMLEntity(MMLRoot* root);
    
    virtual ~MMLEntity();
    
    virtual void store(mvar& v) const;
    
    virtual void store(mvar& v, bool recursive) const;
    
    static MMLEntity* ptr(const mvar& v, bool dynamic=false);
    
    virtual MObject* clone() const;
    
    virtual mnode process(mnode n, uint32_t flags=0);
    
    virtual bool instanceOf(ClassIdType classId) const;
    
    virtual void assignId();
    
    virtual void releaseId();
    
    virtual mvar init();
    
    void setId(int id);
    
    int id() const;
    
    void setTag(const mvar& tag);
    
    const mvar& tag() const;
    
    virtual mstr name() const;
    
    bool isThreaded() const;
    
    void setThreaded(bool flag);
    
    virtual MMessageBuffer* initPrivateBuffer();
    
    virtual MMessageBuffer* initSharedBuffer();
    
    MMessageBuffer* privateBuffer() const;
    
    MMessageBuffer* sharedBuffer() const;
    
    void connect(MMLEntity* ent,
                 const mvar& data=undef,
                 const mstr& edgeTag="");
    
    void connect(const mvar& ent,
                 const mvar& data=undef,
                 const mstr& edgeTag="");
    
    virtual void onConnect(MMLEntity* ent, const mstr& edgeTag);
    
    void disconnect(MMLEntity* ent, const mstr& edgeTag);
    
    void disconnect(const mvar& ent, const mstr& edgeTag);
    
    void disconnect(MMLEntity* ent);
    
    void disconnect(const mvar& ent);
    
    void disconnect();
    
    void addLocality(const mstr& attribute, double radius);
    
    void addLocality(const mstr& attribute, double radius, MMLEntity* ent);
    
    void addLocality(const mstr& attribute, double radius, const mvar& ent);
    
    size_t localityCount() const;
    
    const mstr& localityAttribute(size_t i) const;
    
    double localityRadius(size_t i) const;
    
    MMLEntity* localityEntity(size_t i) const;
    
    void removeLocality(const mstr& attribute);
        
    virtual void onDisconnect(MMLEntity* ent, const mstr& edgeTag);
    
    const mvar& edgeData(const MMLEntity* ent, const mstr& edgeTag="") const;

    const mvar& edgeData(const mvar& ent, const mstr& edgeTag="") const;
    
    void setEdgeData(const mvar& ent,
                     const mvar& edgeData,
                     const mstr& edgeTag="");

    void setEdgeData(const MMLEntity* ent,
                     const mvar& edgeData,
                     const mstr& edgeTag="");
    
    virtual void onAttach(MMLEntity* ent, const mstr& edgeTag);
    
    void detach();
    
    virtual void onDetach(MMLEntity* ent, const mstr& edgeTag);
    
    void signal(MMLEntity* ent, const mstr& edgeTag="");
    
    void signal(const mvar& ent, const mstr& edgeTag="");
    
    void signal(MMLEntity* ent, const mvar& v, const mstr& edgeTag);
    
    void signal(const mvar& ent, const mvar& v, const mstr& edgeTag);
    
    void signalAll();
    
    void signalAll(const mvar& v);
    
    size_t outEdgeCount() const;
    
    size_t inEdgeCount() const;
    
    void outEdges(mvec& ents, mvec& edgeTags) const;
    
    void outEdges(mvec& ents) const;
    
    mvec outEdges() const;
    
    void setActive(bool flag);
    
    bool isActive() const;
    
    void queue();
    
    void queue(MProcTask* task,
               MProc::SignalMap* signalMap=0,
               double priority=0,
               const mtime* time=0);
    
    mvar time() const;
    
    mvar interval() const;
    
    virtual mvar run();
    
    void setRunAll(bool flag);
    
    bool runAll() const;
    
    bool isRunCycle() const;
    
    virtual mvar endRun();
    
    const mvar& state() const;
    
    void setKept(bool kept);
    
    bool isKept() const;
    
    void query(mnode func,
               mvec& results,
               bool recursive,
               bool self,
               bool error) const;
    
    mvar query(mnode func,
               bool recursive=false,
               bool self=true,
               bool error=true) const;
    
    void execute(mnode func,
                 bool recursive=false,
                 bool self=true,
                 bool error=true) const;
    
    void find(const mstr& name,
              mvec& results,
              bool recursive,
              bool self) const;
    
    mvar find(const mstr& name,
              bool recursive=false,
              bool self=true) const;
    
    void await();
    
    bool await(const mtime& timeout);
    
    void handleEvents();
    
    virtual mvar handleEvent(const mvar& evt);
    
    void send(MMLEntity* ent, const mvar& evt, const mvar& delay);
    
    void send(const mvar& ent, const mvar& evt, const mvar& delay);
    
    void send(MMLEntity* ent, const mvar& evt);
    
    void send(const mvar& ent, const mvar& evt);
    
    void relay(const mvar& evt, const mvar& delay);
    
    void relay(const mvar& evt);
    
    void post(MMLEntity* ent, const mvar& evt, const mvar& delay);
    
    void post(const mvar& ent, const mvar& evt, const mvar& delay);
    
    void post(MMLEntity* ent, const mvar& evt);
    
    void post(const mvar& ent, const mvar& evt);
    
    void log(const mvar& msg, bool concise=true) const;
    
    void listen(MMLEntity* ent);
    
    void listen(const mvar& ent);
    
    virtual mvar end();
    
    mvar getLinks(mnode f=mfunc("List"));
    
    void lock();
    
    void unlock();
    
    friend class MMLEntity_;
    friend class MMLRoot_;
  
    MMLRoot* rootPtr();
    
  protected:
    mvar root;
    
  private:
    MMLEntity& operator=(const MMLEntity&);
    
    class MMLEntity_* x_;
  };
  
  std::ostream& operator<<(std::ostream& ostr, const MMLEntity& ent);
  
} // end namespace Meta

#endif // ANDROMETA_MML_ENTITY_H