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

#include <sbgCommon.h>

//----------------------------------------------------------------------//
//- Structure definitions                                              -//
//----------------------------------------------------------------------//

typedef enum _SbgInterfaceType
{
        SBG_IF_TYPE_UNKNOW,                                                             
        SBG_IF_TYPE_SERIAL,                                                             
        SBG_IF_TYPE_ETH_UDP,                                                    
        SBG_IF_TYPE_ETH_TCP_IP,                                                 
        SBG_IF_TYPE_FILE                                                                
} SbgInterfaceType;

//----------------------------------------------------------------------//
//- 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 bool (*SbgInterfaceIsValidFunc)(SbgInterface *pHandle);

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

struct _SbgInterface
{
        SbgInterfaceHandle                       handle;                                                        
        SbgInterfaceType                         type;                                                          
        SbgInterfaceWriteFunc           pWriteFunc;                                                     
        SbgInterfaceReadFunc            pReadFunc;                                                      
        SbgInterfaceIsValidFunc         pIsValidFunc;                                           
};

//----------------------------------------------------------------------//
//- Inline operations methods                                          -//
//----------------------------------------------------------------------//

SBG_INLINE void sbgInterfaceZeroInit(SbgInterface *pHandle)
{
        //
        //      Test input argument
        //
        SBG_ASSERT(pHandle);

        //
        // Initialize all fields to NULL
        //
        pHandle->handle                 = NULL;
        pHandle->type                   = SBG_IF_TYPE_UNKNOW;
        pHandle->pWriteFunc             = NULL;
        pHandle->pReadFunc              = NULL;
        pHandle->pIsValidFunc   = NULL;
}

SBG_INLINE bool sbgInterfaceIsValid(SbgInterface *pHandle)
{
        //
        // Check input arguments
        //
        SBG_ASSERT(pHandle);

        //
        // To be valid, an interface should have a valid name, type and read / write method
        // Optionally, we can also ask the interface to return a validity flag
        //
        if ( (pHandle->type != SBG_IF_TYPE_UNKNOW) && (pHandle->pWriteFunc) && (pHandle->pReadFunc) )
        {
                //
                // Check if this interface has a specific valid method
                //
                if (pHandle->pIsValidFunc)
                {
                        //
                        // Return the status of the interface specific valid method
                        //
                        return pHandle->pIsValidFunc(pHandle);
                }
                else
                {
                        //
                        // This interface is valid
                        //
                        return true;
                }
        }
        else
        {
                //
                // This interface is invalid
                //
                return false;
        }
}

SBG_INLINE SbgErrorCode sbgInterfaceWrite(SbgInterface *pHandle, const void *pBuffer, size_t bytesToWrite)
{
        //
        //      Test input arguments
        //
        SBG_ASSERT(pHandle);
        SBG_ASSERT(pBuffer);

        //
        // 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)
{
        //
        //      Test input arguments
        //
        SBG_ASSERT(pHandle);
        SBG_ASSERT(pBuffer);
        SBG_ASSERT(pReadBytes);

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

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

#endif /* __INTERFACE_H__ */