gzPipe.h

Go to the documentation of this file.

// *****************************************************************************
// File         : gzPipe.h
// Module       : gzBase
// Description  : Class definition of Pipes classes
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training System AB, Sweden
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  030912  Created file    
//
// ******************************************************************************

#ifndef __GZ_PIPE_H__
#define __GZ_PIPE_H__

#include "gzBasicTypes.h"
#include "gzMemory.h"
#include "gzDynamic.h"
#include "gzThread.h"
#include "gzNotify.h"

class gzPipe; // Forward decl

class gzSocket; // Forward decl (from gzNetwork.h)


enum gzPipeConnection
{
    GZ_PIPE_LOCAL,
    GZ_PIPE_GLOBAL
};


//******************************************************************************
// Class    : gzPipeData
//                                  
// Purpose  : A data container used by the gzPipeServer
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  030917  Created 
//                                  
//******************************************************************************
class gzPipeData
{
public:

    gzUByte *adress;

    gzULong len;
};

typedef gzPipeData * gzPipeDataPtr;


//******************************************************************************
// Class    : gzPipeRecieveDataInterface
//                                  
// Purpose  : Interface to receive data from a pipe through a callback
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  030917  Created 
//                                  
//******************************************************************************

class gzPipeRecieveDataInterface : public gzNotifySlave<gzPipe,gzPipeRecieveDataInterface,gzPipeDataPtr>
{
public:

    virtual GZ_BASE_EXPORT gzVoid onPipeRecieveData(gzPipe *pipe, gzUByte *adress , gzULong len)=0;

    virtual GZ_BASE_EXPORT gzVoid onPipeTerminate(gzPipe *pipe){};


    gzVoid GZ_BASE_EXPORT onNotify(gzPipe *notifier,gzPipeDataPtr &data,gzULong senderClass);

};

//******************************************************************************
// Class    : gzPipeConnectionInterface
//                                  
// Purpose  : Controls the connection
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  030917  Created 
//                                  
//******************************************************************************
class gzPipeControlInterface
{
public:
        // Connection management
    GZ_BASE_EXPORT virtual gzBool   onPipeOpenRequest(const gzString &pipeID , const gzString &optionString)    { return TRUE; }
    GZ_BASE_EXPORT virtual gzBool   onPipeOpenAck(const gzString &pipeID , const gzString &optionString)        { return TRUE; }
};

//******************************************************************************
// Class    : gzPipe
//                                  
// Purpose  : Actual named pipe implementation
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  030917  Created 
//                                  
//******************************************************************************

class gzPipe : public gzThread , public gzNotifyMaster<gzPipe,gzPipeRecieveDataInterface,gzPipeDataPtr> , public gzSerializeAdapter , public gzMutex
{
public:

    GZ_BASE_EXPORT gzPipe(gzPipeControlInterface *pipeControl=NULL);

    GZ_BASE_EXPORT virtual ~gzPipe();


    GZ_BASE_EXPORT gzBool connect( const gzString &name, gzBool create=FALSE, gzPipeConnection connection=GZ_PIPE_GLOBAL, gzULong timeOutRetry=50 , const gzString &optionString=GZ_EMPTY_STRING);

    GZ_BASE_EXPORT gzBool createPipe(const gzUShort port,gzULong timeOutRetry=50);

    GZ_BASE_EXPORT gzBool openPipe(const gzString &address,gzUShort port,gzULong timeOutRetry=50);


    GZ_BASE_EXPORT gzBool isConnected();

    GZ_BASE_EXPORT gzVoid disconnect(gzBool waitForRemoteConnection=TRUE);

    GZ_BASE_EXPORT gzULong writePipe(gzUByte *adress, gzULong len);


    GZ_BASE_EXPORT gzULong readPipe( gzUByte *adress, gzULong maxlen, gzBool blocking=TRUE);

    GZ_BASE_EXPORT gzULong pendingBytes();

    
    // Serialize interface

    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte data);

    GZ_BASE_EXPORT virtual gzUByte  read_imp();

    GZ_BASE_EXPORT virtual gzVoid   write_imp(gzUByte *data, gzULong count);
    
    GZ_BASE_EXPORT virtual gzULong  read_imp(gzUByte *data, gzULong maxcount);
    
    GZ_BASE_EXPORT virtual gzULong  length_imp();

    // properties

    GZ_PROPERTY_GET_EXPORT( gzString,       PipeName,       GZ_BASE_EXPORT);
    GZ_PROPERTY_GET_EXPORT( gzString,       PipeID,         GZ_BASE_EXPORT);
    GZ_PROPERTY_GET_EXPORT( gzString,       RemotePipeID,   GZ_BASE_EXPORT);

    GZ_PROPERTY_GET_EXPORT( gzUShort,       PipePort,       GZ_BASE_EXPORT);
    GZ_PROPERTY_GET_EXPORT( gzBool,         DirectConnect,  GZ_BASE_EXPORT);

private:

    gzBool createNamedPipe(gzULong timeOutRetry);
    gzBool openNamedPipe(gzULong timeOutRetry);

    GZ_BASE_EXPORT virtual gzVoid process();

    gzSocket*                           m_pipeSocket;

    gzBool                              m_createPipe;

    gzPipeConnection                    m_connection:8;

    gzList<gzPipeRecieveDataInterface>  m_subscribers;

    gzString                            m_optionString;

    gzPipeControlInterface              *m_pipeControl;
    
    gzULong                             m_pipeRequestID;

    static gzMutex                      s_lastRequestIDLocker;

    static gzDict<gzString,gzVoid>      s_lastRequestID;

    static  gzMutex                     s_pipePortLocker;

    static gzQueue<gzUShort>            s_pipePortStack;

    static gzBool                       s_pipePortStackInitialised;
};


//******************************************************************************
// Class    : gzPipeServer
//                                  
// Purpose  : Actual named pipe server implementation. Echoes between all pipes
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  030917  Created 
//                                  
//******************************************************************************

class gzPipeServer : public gzThread , public gzPipeRecieveDataInterface , public gzPipeControlInterface
{
public:

    GZ_BASE_EXPORT gzPipeServer(const gzString &pipeName);

    GZ_BASE_EXPORT virtual ~gzPipeServer();

    GZ_BASE_EXPORT gzVoid doEchoPipeData(gzBool on);

    GZ_BASE_EXPORT virtual gzVoid stop(gzBool waitForStop=FALSE);

protected:

    virtual GZ_BASE_EXPORT gzVoid onPipeRecieveData(gzPipe *pipe, gzUByte *adress , gzULong len);

    virtual GZ_BASE_EXPORT gzVoid onPipeTerminate(gzPipe *pipe);

    virtual gzVoid process();

    gzString                m_pipeName; 

    gzRefList<gzPipe>       m_pipeList;

    gzMutex                 m_pipeListLocker;

    gzBool                  m_checkPipeRemoval:1;

    gzBool                  m_doEchoPipeData:1;

};


//******************************************************************************
// Class    : gzPipeURLServer
//                                  
// Purpose  : Works like a pipe URL server on remote hosts
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  030917  Created 
//                                  
//******************************************************************************
class gzPipeURLServer : public gzPipeServer
{
public:

    GZ_BASE_EXPORT gzPipeURLServer(const gzString &pipeName);

    GZ_BASE_EXPORT virtual ~gzPipeURLServer();

protected:

    GZ_BASE_EXPORT virtual gzBool   onPipeOpenRequest(const gzString &pipeID , const gzString &optionString);
    GZ_BASE_EXPORT virtual gzBool   onPipeOpenAck(const gzString &pipeID , const gzString &optionString);

    virtual GZ_BASE_EXPORT gzVoid onPipeRecieveData(gzPipe *pipe, gzUByte *adress , gzULong len);
};

#endif // __GZ_PIPE_H__

---