fd_adapter.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef __FD_ADAPTER_H
#define __FD_ADAPTER_H
 
#include <basictypes.h>
#include <iosys.h>
#include <buffers.h>
 
#define MAX_FDBUFFER_FIFO_BUFFERS   (20)
 
class fd_adapter
{
   protected:
    int my_fd;
    bool inDtor;
 
    virtual int read(char *buf, int nbytes) = 0;
    virtual int write(const char *buf, int nbytes) = 0;
    virtual int close() = 0;
    static int sread(int fd, char *buf, int nbytes);
    static int swrite(int fd, const char *buf, int nbytes);
    static int sclose(int fd);
    static fd_adapter *GetFromFD(int fd);
 
   public:
    fd_adapter() {my_fd=0; inDtor = false;};
    // You _cannot_ call ::close inside the pure virtual base class.
    //   The reason is that by the time we get here, the derived class is destroyed,
    //   which means that the vtable we hit is the base class, which in turn
    //   has a pure virtual method for close. When the naked scope close method
    //   is called, this will hit the fd_adapter sclose which
    ~fd_adapter() { inDtor = true; if (my_fd) ::close(my_fd); };
    operator int() { if(my_fd==0) GetActiveFD(); return my_fd;};
    int GetActiveFD();
 
};
 
class FDCounter : public fd_adapter
{
    int nwr;
 
    virtual int read(char *buf, int nbytes);
    virtual int write(const char *buf, int nbytes);
    virtual int close();
 
   public:
    FDCounter() { nwr = 0; };
    ~FDCounter() { if (my_fd) ::close(my_fd); }
 
    int SpaceUsed() { return nwr; };
};
 
class FDFlash : public fd_adapter
{
    uint32_t m_len;
    uint32_t m_cs;
    uint8_t buffer[64];
    uint8_t *pd;
    uint32_t blen;
 
    virtual int read(char *buf, int nbytes);
    virtual int write(const char *buf, int nbytes);
    virtual int close();
 
    void Flush();
 
   public:
    FDFlash(uint8_t *pw)
    {
        pd = pw;
        m_len = 0;
        m_cs = 0;
        blen = 0;
        buffer[0] = '\0';
    };
 
    uint32_t cs() { return m_cs; };
 
    uint32_t len() { return m_len; };
};
 
class FDBuffer : public fd_adapter
{
    fifo_buffer_storage bs{MAX_FDBUFFER_FIFO_BUFFERS, 0};
    int nwr;
 
    int read(char *buf, int nbytes) override;
    int write(const char *buf, int nbytes) override;
    int close() override;
 
   public:
    void Reset()
    {
        bs.Reset(MAX_FDBUFFER_FIFO_BUFFERS);
        nwr = 0;
    };
 
    bool StreamTo(int fd);   // Returns true when done
 
    FDBuffer() { nwr = 0; };
 
    int SpaceUsed() { return nwr; };
};
 
class FDcBuf : public fd_adapter
{
    OS_CRIT crit;
    uint8_t *cbuf;
    int rdIdx;
    int wrIdx;
    int bufLen;
    int blockWaitSkip;
    bool empty;
 
    int read(char *buf, int nbytes) override;
    int write(const char *buf, int nbytes) override;
    int close() override;
 
   public:
    inline void Reset(int nWritten = -1)
    {
        rdIdx = 0;
        if ((nWritten >= 0) && (nWritten < (bufLen-1)))
            wrIdx = nWritten;
        else
            wrIdx = 0;
        empty = true;
    }
 
    FDcBuf(uint8_t *buf, int _bufLen, int _blockWaitSkip = 1)
        : cbuf(buf), rdIdx(0), wrIdx(0), bufLen(_bufLen),
            blockWaitSkip(_blockWaitSkip), empty(true)
    { }
    ~FDcBuf()
    {
        if (my_fd)
            ::close(my_fd);
 
    }
 
    inline int SpaceUsed() { return wrIdx - rdIdx + ((rdIdx > wrIdx)*bufLen); };
};
#endif /* ----- #ifndef __FD_ADAPTER_H  ----- */