sbgInterface.h

Go to the documentation of this file.

#ifndef SBG_INTERFACE_H
#define SBG_INTERFACE_H

//----------------------------------------------------------------------//
//- Header (open extern C block)                                       -//
//----------------------------------------------------------------------//
#ifdef __cplusplus
extern "C" {
#endif

/* sbgCommonLib headers */
#include <sbgCommon.h>

//----------------------------------------------------------------------//
//- Constant definitions                                               -//
//----------------------------------------------------------------------//

#define SBG_IF_NAME_MAX_SIZE            (48)                    
#define SBG_IF_TYPE_UNKNOW                      (0)                             
#define SBG_IF_TYPE_SERIAL                      (1)                             
#define SBG_IF_TYPE_ETH_UDP                     (2)                             
#define SBG_IF_TYPE_ETH_TCP_IP          (3)                             
#define SBG_IF_TYPE_FILE                        (4)                             
#define SBG_IF_TYPE_LAST_RESERVED       (999)                   
//----------------------------------------------------------------------//
//- Predefinitions                                                     -//
//----------------------------------------------------------------------//

typedef struct _SbgInterface SbgInterface;

typedef void* SbgInterfaceHandle;

//----------------------------------------------------------------------//
//- Callbacks definitions                                              -//
//----------------------------------------------------------------------//

typedef SbgErrorCode (*SbgInterfaceWriteFunc)(SbgInterface *pHandle, const void *pBuffer, size_t bytesToWrite);

typedef SbgErrorCode (*SbgInterfaceReadFunc)(SbgInterface *pHandle, void *pBuffer, size_t *pReadBytes, size_t bytesToRead);

typedef SbgErrorCode (*SbgInterfaceFlushFunc)(SbgInterface *pHandle);

typedef uint32_t (*SbgInterfaceGetDelayFunc)(SbgInterface *pHandle, size_t numBytes);

//----------------------------------------------------------------------//
//- Structures definitions                                             -//
//----------------------------------------------------------------------//

struct _SbgInterface
{
        SbgInterfaceHandle                       handle;                                                        
        uint32_t                                         type;                                                          
        char                                             name[SBG_IF_NAME_MAX_SIZE];            
        SbgInterfaceWriteFunc            pWriteFunc;                                            
        SbgInterfaceReadFunc             pReadFunc;                                                     
        SbgInterfaceFlushFunc            pFlushFunc;                                            
        SbgInterfaceGetDelayFunc         pDelayFunc;                                            
};

//----------------------------------------------------------------------//
//- Public methods                                                     -//
//----------------------------------------------------------------------//

SBG_COMMON_LIB_API void sbgInterfaceZeroInit(SbgInterface *pHandle);

SBG_INLINE SbgErrorCode sbgInterfaceWrite(SbgInterface *pHandle, const void *pBuffer, size_t bytesToWrite)
{
        assert(pHandle);
        assert(pBuffer);
        assert(pHandle->pWriteFunc);

        //
        // Call the correct write method according to the interface
        //
        return pHandle->pWriteFunc(pHandle, pBuffer, bytesToWrite);
}

SBG_INLINE SbgErrorCode sbgInterfaceRead(SbgInterface *pHandle, void *pBuffer, size_t *pReadBytes, size_t bytesToRead)
{
        assert(pHandle);
        assert(pBuffer);
        assert(pReadBytes);
        assert(pHandle->pReadFunc);

        //
        // Call the correct read method according to the interface
        //
        return pHandle->pReadFunc(pHandle, pBuffer, pReadBytes, bytesToRead);
}

SBG_INLINE SbgErrorCode sbgInterfaceFlush(SbgInterface *pHandle)
{
        SbgErrorCode             errorCode;

        assert(pHandle);

        //
        // The Flush method is optional so check if it has been defined.
        //
        if (pHandle->pFlushFunc)
        {
                //
                // Call the correct flush method according to the interface
                //
                errorCode = pHandle->pFlushFunc(pHandle);
        }
        else
        {
                errorCode = SBG_NO_ERROR;
        }

        return errorCode;
}

SBG_INLINE uint32_t sbgInterfaceGetDelay(SbgInterface *pHandle, size_t numBytes)
{
        assert(pHandle);

        //
        // The get delay method is optional so check if it has been defined.
        //
        if (pHandle->pDelayFunc)
        {
                //
                // Call the correct flush method according to the interface
                //
                return pHandle->pDelayFunc(pHandle, numBytes);
        }
        
        return 0;
}

SBG_INLINE uint32_t sbgInterfaceTypeGet(const SbgInterface *pInterface)
{
        assert(pInterface);

        return pInterface->type;
}

SBG_COMMON_LIB_API const char *sbgInterfaceTypeGetAsString(const SbgInterface *pInterface);

SBG_INLINE const char *sbgInterfaceNameGet(const SbgInterface *pInterface)
{
        assert(pInterface);

        return pInterface->name;
}

SBG_COMMON_LIB_API void sbgInterfaceNameSet(SbgInterface *pInterface, const char *pName);

//----------------------------------------------------------------------//
//- Footer (close extern C block)                                      -//
//----------------------------------------------------------------------//
#ifdef __cplusplus
}
#endif

#endif /* SBG_INTERFACE_H */