coSimLib.h

Go to the documentation of this file.

/* This file is part of COVISE.

   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.

 * License: LGPL 2+ */

#ifndef _CO_SIM_LIB_H_
#define _CO_SIM_LIB_H_

// 11.06.99

#include <sys/types.h>
#include <set>
#include <list>
#include <util/coviseCompat.h>
#ifndef YAC
#include <api/coModule.h>
#include <covise/covise.h>
#else
#include <comm/logic/coSocketListener.h>
#endif
#include <net/covise_connect.h>

namespace covise
{

class command_object
{

public:
    command_object(int type, char *port = 0, char *name = 0, char *data = 0, int length = 0, int numComp = 0, int actNode = 0)
        : _type(type)
        , _port(port)
        , _name(name)
        , _data(data)
        , _length(length)
        , _numComp(numComp)
        , _actNode(actNode)
    {
    }

    ~command_object()
    {
        if (_port)
            delete[] _port;
        if (_name)
            delete[] _name;
        if (_data)
            delete[] _data;
    }

    // private:
    int _type;
    char *_port, *_name, *_data;
    int _length, _numComp, _actNode;
};

#ifndef YAC
class APIEXPORT coSimLib : public coModule
#else
class APIEXPORT coSimLib : public coSimpleModule, public coSocketListener
#endif
{
public:
    typedef int int32;

// execute commands received from the simulation in sockData()
#ifndef YAC
    void executeCommands();
#else
    void executeCommands(std::set<coOutputPort *> *);
#endif

    // overload coModule sockData routine and make it private
    virtual void sockData(int sockNo);

private:
    // ---------- Internal member functions ----------------------------

    uint32_t nslookup(const char *name);

    // Open a TCP server
    int openServer();

    // Open a TCP client
    int openClient();

    // Accept a TCP server
    int acceptServer(float wait);

    // handle all Commands
    int handleCommand(/*int fromWhere*/);

    // ---------- Class data -------------------------------------------

    // number of user-defined arguments in call and contents
    char *d_userArg[10];

    // IP number of local and target machine, min/max port number
    uint32_t d_localIP, d_targetIP, d_minPort, d_maxPort, d_usePort;

    // the socket the simulation connects to if COVISE is the server
    int server_socket;

    // Socket number =1 on error or not-yet-open
    int d_socket;

    // Verbose level
    int d_verbose;

    // do we have to byteswap incoming data ?
    bool d_byteswap;

    // the name of the simulation
    char *d_name;

    // active command: if a command is in the 'queue': sent for server, recv in main_loop
    int32 d_command;

    // mapping for parallel data : only ONE mapping right now
    // make better it with list and per-port mapping later!
    int32 **d_cellMap, d_numCells;
    int32 **d_vertMap, d_numVert;
    int d_numNodes;
    struct PortListElem
    {
        const char *name; // name of the port
        int ***map; // mapping for this port: either cell- or vertex
        int numParts; // number of parts collected so far
        coDistributedObject *openObj; // open Object to write into

        PortListElem *next; // chain...

    } *d_portList;

    // when going parallel: active node number. If not: -1;
    int32 d_actNode;

    // all the startup lines we have
    char **d_startup_label;
    const char **d_startup_line;

    // and how many we have
    int d_numStartup;

    // Flag: The simulation requested an EXEC. Cleared by
    //       - C'tor
    //       - startSim
    //       - serverMode
    //       - resetSim
    int d_simExec;

    // list of command objects that were sent during sockData
    // the two pointers are swapped when the simulation sent COMM_QUIT
    std::list<command_object *> *command_objects;
    std::list<command_object *> *tmp_objects;

    // called from sockData when COMM_QUIT command is received
    virtual int endIteration();

    void closeSocket(int socket);

#ifdef YAC
    coCommunicator *comm;
    std::set<coOutputPort *> portList;
#endif
protected:
#include "coSimLibComm.h"

    coSimLib(const coSimLib &);

    coSimLib &operator=(const coSimLib &);

    coSimLib();

    // this allows to choose between the different start-ups
    coChoiceParam *p_StartupSwitch;

    int reAccept();

public:
    coSimLib(int argc, char *argv[], const char *moduleName, const char *desc);

    virtual ~coSimLib();

    int setTargetHost(const char *hostname);
    int setLocalHost(const char *hostname);

    int setUserArg(int num, const char *data);

    int startSim(int reattach = 0);

    //int serverMode();

    void resetSimLib();

    int isConnected();

    int recvData(void *buffer, size_t length);
    int sendData(const void *buffer, size_t length);

    int recvBS_Data(void *buffer, size_t length);
    int sendBS_Data(void *buffer, size_t length);

    int coParallelInit(int numParts, int numPorts);

    int coParallelPort(const char *portName, int isCellData);

    // i.e. local COPCM or COPAVM
    int setParaMap(int isCell, int isFortran, int nodeNo, int length,
                   int32 *nodeMap);

    void setVerbose(int level)
    {
        d_verbose = level;
    }

    int getVerboseLevel()
    {
        return d_verbose;
    }

    coChoiceParam *getStartupChoice()
    {
        return p_StartupSwitch;
    }

    int simRequestExec()
    {
        return d_simExec;
    }

    void setPorts(int min, int max);
};
}
#endif