Connections.h

#ifndef CARMA_UI_RTD_CONNECTIONS_H
#define CARMA_UI_RTD_CONNECTIONS_H

#include <string>
#include "MemoryMappedFile.h"



/*
 * Class definition for the Connections classes. This class keeps track
 * of all connections to the monitoring window package.
 * The memory mapped filename is hardwired to be "connections.shmem"
 * in the mmap directory.
 * 
 * @author Steve Scott
 *
 * $id: $
  *
 * $CarmaCopyright$
 *
 */



namespace carma {
    namespace ui {
        namespace rtd { 




/*
** Define the size of strings and arrays
*/
const int SIZEOF_USERNAME      = 14;
const int SIZEOF_LONGUSERNAME  = 60;
const int SIZEOF_FULLNAME      = 40;
const int SIZEOF_COMPACTNAME   = 40;
const int SIZEOF_LOCATION      = 10;
const int SIZEOF_FULLLOCATION  = 50;
const int SIZEOF_WINDOWNAME    = 20;
const int SIZEOF_CONNECTSTART  = 20;
const int SIZEOF_WINDOWUPDATE  = 10;
const int NUMBEROF_CONNECTIONS = 150;


struct Cnx {
    int     processId; 
    char    windowName[SIZEOF_WINDOWNAME];
    char    userName[SIZEOF_USERNAME];
    char    fullName[SIZEOF_FULLNAME];
    char    compactName[SIZEOF_COMPACTNAME];
    char    location[SIZEOF_LOCATION];  
    char    fullLocation[SIZEOF_FULLLOCATION];
    char    connectStartString[SIZEOF_CONNECTSTART];
    double  connectStartMJD;
    char    windowUpdateRate[SIZEOF_WINDOWUPDATE];
    bool    guest;
    bool    hasControl;  
    bool    valid;       
};

struct ConnectionData {
    int     serialNumber;  
    bool    haveControlUser;   
    bool    reloadInProgress;  
    char    userName[SIZEOF_USERNAME]; 
    char    longUserName[SIZEOF_LONGUSERNAME];  
    Cnx     cnx[NUMBEROF_CONNECTIONS];  
};

class ConnectionBase {
public:
    ConnectionBase(int pid, const std::string& filename, MemoryMappedFile::Protection_t p);
    virtual ~ConnectionBase();
    virtual std::string   toString();
    void          lockRead();
    void          lockWrite();
    void          unlock();
    int getSerialNumber();
    int getMaxConnections();
protected:
    int               pid_;
    ConnectionData*   connection;
    MemoryMappedFile* memMap; 
    std::string            memoryMappedFilename;
private:
};

class ConnectionRW:public ConnectionBase {
public:
    ConnectionRW(int pid, const std::string& filename);

    virtual ~ConnectionRW() {};
    
    void registerWindow( const char * windowName,
                         const char * userName,
                         const char * fullName,
                         const char * location,
                         const char * fullLocation,
                         int          guest );
    void unregisterWindow(int pid);
    void unregisterDeadWindows();
    char* setControl(bool usurp);
    void setUpdateRate(double updateRate);
    void setReloadInProgress(int state);
    int getReloadInProgress();
    void setPID(int _pid);
private:
    void updateCnxControlState();
    char controlChangeMessage[200];
};


class ConnectionRO:public ConnectionBase {
public:
    ConnectionRO(int pid, const std::string& filename);
    virtual ~ConnectionRO() {};
     
    Cnx* getThisCnx();
    ConnectionData* getConnectionData(); 
    int getCacheSerialNumber();
    std::string toString();
    
private:
    ConnectionData cachedData;          // The cached data for ro operations
    int            cnxIndex;            // Index for the cnx for this process
};

 
}}} // End namespace carma::ui::rtd


#endif  // CARMA_UI_RTD_CONNECTIONS_H