HOM_clone.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS:
 */

#ifndef __HOM_clone_h__
#define __HOM_clone_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_ElemPtr.h"
#include <vector>

class HOM_LopNode;
class HOM_clone_Connection;

SWIGOUT(%rename(clone) HOM_clone;)

class HOM_API HOM_clone
{
public:
    virtual ~HOM_clone()
    { }

    virtual std::string __repr__() = 0;

    SWIGOUT(%kwargs runAsClone;)
    virtual void runAsClone(int start_port = 0,
            int end_port = -1,
            bool debug = false,
            bool block = false,
            bool print_port = false,
            int connection_timeout_seconds = -1) = 0;
    virtual bool isRunningAsClone() = 0;

    SWIGOUT(%kwargs createClone;)
    SWIGOUT(%newobject createClone;)
    virtual HOM_clone_Connection *createClone(const char *id = nullptr) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_clone_Connection> > clones() = 0;
    SWIGOUT(%newobject clone;)
    virtual HOM_clone_Connection *clone(const char *id) = 0;
    virtual void deleteClone(const char *id) = 0;
    virtual void deleteDisconnectedClones() = 0;

    SWIGOUT(%ignore addOpaqueConnectionChangeCallback;)
    virtual void addOpaqueConnectionChangeCallback(void *callback) = 0;
    SWIGOUT(%ignore removeOpaqueConnectionChangeCallback;)
    virtual void removeOpaqueConnectionChangeCallback(void *callback) = 0;
    virtual void removeAllConnectionChangeCallbacks() = 0;
    SWIGOUT(%ignore opaqueConnectionChangeCallbacks;)
    virtual std::vector<void *> opaqueConnectionChangeCallbacks() = 0;

    SWIGOUT(%ignore addOpaqueImageChangeCallback;)
    virtual void addOpaqueImageChangeCallback(void *callback) = 0;
    SWIGOUT(%ignore removeOpaqueImageChangeCallback;)
    virtual void removeOpaqueImageChangeCallback(void *callback) = 0;
    virtual void removeAllImageChangeCallbacks() = 0;
    SWIGOUT(%ignore opaqueImageChangeCallbacks;)
    virtual std::vector<void *> opaqueImageChangeCallbacks() = 0;

#ifdef SWIG
%extend
{
    void addConnectionChangeCallback(InterpreterObject callback)
    { self->addOpaqueConnectionChangeCallback(callback); }
    void removeConnectionChangeCallback(InterpreterObject callback)
    { self->removeOpaqueConnectionChangeCallback(callback); }
    // Note that we return a vector of borrowed references because swig
    // will increment the reference counts.
    std::vector<InterpreterObject> connectionChangeCallbacks()
    {
        std::vector<void *> opaque_callbacks(
            self->opaqueConnectionChangeCallbacks());
        std::vector<InterpreterObject> callbacks;
        for (int i=0; i< opaque_callbacks.size(); ++i)
            callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
        return callbacks;
    }

    void addImageChangeCallback(InterpreterObject callback)
    { self->addOpaqueImageChangeCallback(callback); }
    void removeImageChangeCallback(InterpreterObject callback)
    { self->removeOpaqueImageChangeCallback(callback); }
    // Note that we return a vector of borrowed references because swig
    // will increment the reference counts.
    std::vector<InterpreterObject> imageChangeCallbacks()
    {
        std::vector<void *> opaque_callbacks(
            self->opaqueImageChangeCallbacks());
        std::vector<InterpreterObject> callbacks;
        for (int i=0; i< opaque_callbacks.size(); ++i)
            callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
        return callbacks;
    }
}
#endif
};

#endif