base classses.h

#ifndef _BASE_CLASSES_H_
#define _BASE_CLASSES_H_

#include "cpl defs.h"
#include <vector>
#include "mem pool.h"


class CDevice;
class CLogBuffer;
class CMemPool;

/*  Struct with which devices send to data to be written to user (through a comm).
    Data is enqueued using this struct.
    */
typedef struct SData
{
    void*   pHead;  // data to be sent
    DWORD   dwSize; // data size in bytes
    CDevice* pDevice;   // pointer to device that will be called after data has been sent (Result(...))
} SData;

class CComm
{
public:
    CComm(){};
    virtual ~CComm() {};
    virtual int SendData(const SData *pData, __int64 llId) =0;
    virtual void Close() =0;
protected:
    CDevice*    m_pcDevice; // the device which gets notified with ProcessData() of user requests.
    CLogBuffer* m_pcLogBuffer;  // could hold a log
    CMemPool*   m_pcMemPool;    // a memory pool used by this comm.
};

class CDevice
{
public:
    CDevice(const TCHAR szName[]) : m_csName(szName){};
    virtual ~CDevice() {};
    virtual void ProcessData(const void *pHead, DWORD dwSize, __int64 llId) =0;
    virtual void Result(void *pHead, bool bPass) =0;
    virtual DWORD GetInfo(void* pHead, DWORD dwSize)= 0;

    const std::tstring m_csName;
protected:
    CComm*      m_pcComm;   // holds a communicator used by device
    CLogBuffer* m_pcLogBuffer;  // a log to which we can write
    CMemPool*   m_pcMemPool;    // pooled memory used instead of malloc()
    // if something went wrong and isn't fixable this is set to true so that all folowing calls to the object
    // return immidiatly. Typically only the constuctor sets it to to true if initialization was bad so that
    // all subsequent calls to the object don't do anything. But if the constructor returns an error (using a 
    // parameter you shouldn't call this object anyway).
    bool        m_bError;
};


class CMainManager : public CDevice
{
public:
    CMainManager();
    virtual ~CMainManager();
    int Run(int argc, TCHAR* argv[]);
    void ProcessData(const void *pHead, DWORD dwSize, __int64 llId);
    void Result(void *pHead, bool bPass) {if (m_pcMemPool) m_pcMemPool->PoolRelease(pHead);}
    DWORD GetInfo(void* pHead, DWORD dwSize){return 0;}
private:
    std::vector<CDevice*>       m_acManagers;   // holds all the managers, their channels numbers are position in this array.
    HANDLE                      m_hClose;       // this event is set when we want to the exe to exit
    std::tstring                m_csPipe;       // the main pipe name.
};


class CManager : public CDevice
{
public:
    CManager(const TCHAR szName[], const std::tstring csPipeName, int nChan) : CDevice(szName), 
    m_csPipeName(csPipeName), m_nChan(nChan){};
    virtual ~CManager(){};
    virtual void ProcessData(const void *pHead, DWORD dwSize, __int64 llId)= 0;
    virtual void Result(void *pHead, bool bPass)= 0;
    virtual DWORD GetInfo(void* pHead, DWORD dwSize)= 0;

    const std::tstring              m_csPipeName;
    const int                       m_nChan;
protected:
    // typically, a manager will load some dll, this dll is held here and is unloaded when the manager is closed.
    HINSTANCE m_hLib;
};

#endif