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 */