diagnostics.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/


 
#ifndef DIAGNOSTICS_INTERNAL_H
#define DIAGNOSTICS_INTERNAL_H
 
#include <nbstring.h>

class DiagItemClass
{
   private:
    NBString Name;                                          
    DiagItemClass *m_pNext;                                 
    virtual void ServeContent(int fd) = 0;                 
    void ServeSubContent(int fd,NBString & remainder);      
    static void ServerRoot(int fd, const char *pUrl);      
    void InsertInList();                                    
    void RemoveList();                                      
 
   public:
       static void ServeBody(int fd);
    DiagItemClass(const char *name);
    DiagItemClass(const NBString &ns);
    ~DiagItemClass();
};

typedef void(diagcallback)(int sock);
 

class DiagCallBack : public DiagItemClass
{
    diagcallback *m_pF;                                     
    virtual void ServeContent(int fd) { m_pF(fd); }        
   public:
    DiagCallBack(const char *name, diagcallback *pFunc) : DiagItemClass(name) { m_pF = pFunc; }
};
 
 

class DiagVarMon : public DiagItemClass
{
   private:
    volatile void *p;                                       
    size_t siz;                                            
    uint16_t flag;                                         
 
   public:
    DiagVarMon(const char *name, uint32_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 1;
    };
    DiagVarMon(const char *name, uint16_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 1;
    };
    DiagVarMon(const char *name, uint8_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 1;
    };
    DiagVarMon(const char *name, int32_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, int16_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, int8_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, char &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, int &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, volatile uint32_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 1;
    };
    DiagVarMon(const char *name, volatile uint16_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 1;
    };
    DiagVarMon(const char *name, volatile uint8_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 1;
    };
    DiagVarMon(const char *name, volatile int32_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, volatile int16_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, volatile int8_t &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, volatile char &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, volatile int &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 0;
    };
    DiagVarMon(const char *name, volatile float &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 2;
    };
    DiagVarMon(const char *name, volatile double &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 2;
    };
    DiagVarMon(const char *name, float &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 2;
    };
    DiagVarMon(const char *name, double &v) : DiagItemClass(name)
    {
        p = &v;
        siz = sizeof(v);
        flag = 2;
    };
    virtual void ServeContent(int fd);
};
 

class DiagStrMon : public DiagItemClass
{
   private:
    volatile const char *pString;                          
    NBString * pStrStr;                                    
 
   public:
    DiagStrMon(const char *name, const char *pstr) : DiagItemClass(name) { pString = pstr;  pStrStr=0;};
    
    DiagStrMon(const char *name, NBString & s) : DiagItemClass(name) { pString = 0;  pStrStr=&s;};
    
    virtual void ServeContent(int fd);                     
};
 

class DiagPtrMon : public DiagItemClass
{
   private:
    volatile void *pPtr;                                   
 
   public:
    DiagPtrMon(const char *name, void *p) : DiagItemClass(name) { pPtr = p; };
    
    virtual void ServeContent(int fd);                     
};

class ParsedURI;

bool SendDiagReport(const char * pUrl,const char *pUser = 0, const char *pPass = 0);

bool SendDiagReport(ParsedURI & uri,const char *pUser = 0, const char *pPass = 0 );

void InitPlatformDiag();
 
#endif