sbgVersion.h

Go to the documentation of this file.

 
#ifndef SBG_VERSION_H
#define SBG_VERSION_H
 
//----------------------------------------------------------------------//
//- Header (open extern C block)                                       -//
//----------------------------------------------------------------------//
#ifdef __cplusplus
extern "C" {
#endif
 
#include <sbgCommon.h>
 
//----------------------------------------------------------------------//
//- Version related definitions                                        -//
//----------------------------------------------------------------------//
#define SBG_VERSION_SOFT_SCHEME                                         (0x00000001u << 31)     
#define SBG_VERSION_SOFT_SCHEME_QUALIFIER_MASK          (0x07)                          
#define SBG_VERSION_SOFT_SCHEME_QUALIFIER_SHIFT         (28)                            
#define SBG_VERSION_SOFT_SCHEME_MAJOR_MASK                      (0x3F)                          
#define SBG_VERSION_SOFT_SCHEME_MAJOR_SHIFT                     (22)                            
#define SBG_VERSION_SOFT_SCHEME_MINOR_MASK                      (0x3F)                          
#define SBG_VERSION_SOFT_SCHEME_MINOR_SHIFT                     (16)                            
#define SBG_VERSION_SOFT_SCHEME_BUILD_MASK                      (0xFFFF)                        
#define SBG_VERSION_SOFT_SCHEME_BUILD_SHIFT                     (0)                                     
typedef enum _SbgVersionQualifier
{
        SBG_VERSION_QUALIFIER_DEV                               = 0,                                                    
        SBG_VERSION_QUALIFIER_ALPHA                             = 1,                                                    
        SBG_VERSION_QUALIFIER_BETA                              = 2,                                                    
        SBG_VERSION_QUALIFIER_RC                                = 3,                                                    
        SBG_VERSION_QUALIFIER_STABLE                    = 4,                                                    
        SBG_VERSION_QUALIFIER_HOT_FIX                   = 5                                                             
} SbgVersionQualifier;
 
typedef enum _SbgVersionCmpThresold
{
        SBG_VERSION_CMP_THRESOLD_MAJOR                  = 0,                                                    
        SBG_VERSION_CMP_THRESOLD_MINOR                  = 1,                                                    
        SBG_VERSION_CMP_THRESOLD_REVISION               = 2,                                                    
        SBG_VERSION_CMP_THRESOLD_BUILD                  = 3,                                                    
        SBG_VERSION_CMP_THRESOLD_QUALIFIER              = 4                                                             
} SbgVersionCmpThresold;
 
typedef struct _SbgVersion
{
        bool                                    softwareScheme;                         
        SbgVersionQualifier             qualifier;                                      
        uint8_t                                 major;                                          
        uint8_t                                 minor;                                          
        uint8_t                                 rev;                                            
        uint16_t                                build;                                          
} SbgVersion;
 
//----------------------------------------------------------------------//
//- Macro definitions for encode versions                              -//
//----------------------------------------------------------------------//
 
#define SBG_VERSION_BASIC(major, minor, rev, build)                                     (       (((uint32_t)(major)) << 24)     |               \
                                                                                                                                                (((uint32_t)(minor)) << 16)     |               \
                                                                                                                                                (((uint32_t)(rev)) << 8)                |               \
                                                                                                                                                (((uint32_t)(build)))                   )
 
#define SBG_VERSION_SOFTWARE(major, minor, build, qualifier)            (       SBG_VERSION_SOFT_SCHEME |                                                                                                                                                                               \
                                                                                                                                                ((((uint32_t)(qualifier)) & SBG_VERSION_SOFT_SCHEME_QUALIFIER_MASK) << SBG_VERSION_SOFT_SCHEME_QUALIFIER_SHIFT) |       \
                                                                                                                                                ((((uint32_t)(major)) & SBG_VERSION_SOFT_SCHEME_MAJOR_MASK) << SBG_VERSION_SOFT_SCHEME_MAJOR_SHIFT)             |               \
                                                                                                                                                ((((uint32_t)(minor)) & SBG_VERSION_SOFT_SCHEME_MINOR_MASK) << SBG_VERSION_SOFT_SCHEME_MINOR_SHIFT)             |               \
                                                                                                                                                ((((uint32_t)(build)) & SBG_VERSION_SOFT_SCHEME_BUILD_MASK) << SBG_VERSION_SOFT_SCHEME_BUILD_SHIFT)             )
 
//----------------------------------------------------------------------//
//- Version encoding / decoding methods                                -//
//----------------------------------------------------------------------//
 
SBG_COMMON_LIB_API void sbgVersionDecode(uint32_t encodedVersion, SbgVersion *pVersionInfo);
 
SBG_COMMON_LIB_API uint32_t sbgVersionEncode(const SbgVersion *pVersionInfo);
 
//----------------------------------------------------------------------//
//- Version parameters methods                                         -//
//----------------------------------------------------------------------//
 
SBG_INLINE bool sbgVersionIsUsingSoftwareScheme(uint32_t encodedVersion)
{
        SbgVersion      decodedVersion;
 
        //
        // Decode the version first
        //
        sbgVersionDecode(encodedVersion, &decodedVersion);
 
        //
        // Returns if the version is using a software scheme
        //
        return decodedVersion.softwareScheme;
}
 
//----------------------------------------------------------------------//
//- Version comparaison methods                                        -//
//----------------------------------------------------------------------//
 
SBG_COMMON_LIB_API int32_t sbgVersionCompare(const SbgVersion *pVersionA, const SbgVersion *pVersionB, SbgVersionCmpThresold thresold);
 
SBG_COMMON_LIB_API int32_t sbgVersionCompareEncoded(uint32_t versionA, uint32_t versionB, SbgVersionCmpThresold thresold);
 
SBG_COMMON_LIB_API int32_t sbgVersionIsWithinRange(const SbgVersion *pLowerVersion, const SbgVersion *pHigherVersion, const SbgVersion *pVersion);
 
SBG_COMMON_LIB_API int32_t sbgVersionIsWithinRangeEncoded(uint32_t lowerVersion, uint32_t higherVersion, uint32_t version);
 
 
//----------------------------------------------------------------------//
//- Version to string methods                                          -//
//----------------------------------------------------------------------//
 
SBG_COMMON_LIB_API SbgErrorCode sbgVersionToString(const SbgVersion *pVersionInfo, char *pBuffer, uint32_t sizeOfBuffer);
 
SBG_COMMON_LIB_API SbgErrorCode sbgVersionToStringEncoded(uint32_t version, char *pBuffer, uint32_t sizeOfBuffer);
 
//----------------------------------------------------------------------//
//- String to version methods                                          -//
//----------------------------------------------------------------------//
 
SBG_COMMON_LIB_API SbgErrorCode sbgVersionFromString(const char *pVersionStr, SbgVersion *pVersionInfo);
 
SBG_COMMON_LIB_API SbgErrorCode sbgVersionFromStringEncoded(const char *pVersionStr, uint32_t *pVersion);
 
//----------------------------------------------------------------------//
//- Legacy version system methods                                      -//
//----------------------------------------------------------------------//
 
SBG_DEPRECATED(SBG_INLINE uint32_t SBG_VERSION(uint8_t major, uint8_t minor, uint8_t rev, uint8_t build));
SBG_DEPRECATED(SBG_INLINE uint8_t SBG_VERSION_GET_MAJOR(uint32_t encodedVersion));
SBG_DEPRECATED(SBG_INLINE uint8_t SBG_VERSION_GET_MINOR(uint32_t encodedVersion));
SBG_DEPRECATED(SBG_INLINE uint8_t SBG_VERSION_GET_REV(uint32_t encodedVersion));
SBG_DEPRECATED(SBG_INLINE uint8_t SBG_VERSION_GET_BUILD(uint32_t encodedVersion));
 
SBG_INLINE uint32_t SBG_VERSION(uint8_t major, uint8_t minor, uint8_t rev, uint8_t build)
{
    //
    // The SBG_VERSION macro is the basic version scheme.
    //
    return SBG_VERSION_BASIC(major, minor, rev, build);
}
 
SBG_INLINE uint8_t SBG_VERSION_GET_MAJOR(uint32_t encodedVersion)
{
        SbgVersion      versionInfo;
 
        //
        // Decode the version information
        //
        sbgVersionDecode(encodedVersion, &versionInfo);
 
        //
        // Return the major version
        //
        return versionInfo.major;
}
 
SBG_INLINE uint8_t SBG_VERSION_GET_MINOR(uint32_t encodedVersion)
{
        SbgVersion      versionInfo;
 
        //
        // Decode the version information
        //
        sbgVersionDecode(encodedVersion, &versionInfo);
 
        //
        // Return the major version
        //
        return versionInfo.minor;
}
 
SBG_INLINE uint8_t SBG_VERSION_GET_REV(uint32_t encodedVersion)
{
        SbgVersion      versionInfo;
 
        //
        // Decode the version information
        //
        sbgVersionDecode(encodedVersion, &versionInfo);
 
        //
        // Return the major version
        //
        return versionInfo.rev;
}
 
SBG_INLINE uint8_t SBG_VERSION_GET_BUILD(uint32_t encodedVersion)
{
        SbgVersion      versionInfo;
 
        //
        // Decode the version information
        //
        sbgVersionDecode(encodedVersion, &versionInfo);
 
        //
        // Return the major version
        //
        return (uint8_t)versionInfo.build;
}
 
//----------------------------------------------------------------------//
//- Footer (close extern C block)                                      -//
//----------------------------------------------------------------------//
#ifdef __cplusplus
}
#endif
 
#endif  /* SBG_VERSION_H */