sbgVersion.h

Go to the documentation of this file.

 
#ifndef SBG_VERSION_H
#define SBG_VERSION_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Project headers
#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 _SbgVersionCmpThreshold
{
    SBG_VERSION_CMP_THRESHOLD_MAJOR         = 0,                            
    SBG_VERSION_CMP_THRESHOLD_MINOR         = 1,                            
    SBG_VERSION_CMP_THRESHOLD_REVISION      = 2,                            
    SBG_VERSION_CMP_THRESHOLD_BUILD         = 3,                            
    SBG_VERSION_CMP_THRESHOLD_QUALIFIER     = 4                             
} SbgVersionCmpThreshold;
 
/*
 * DEPRECATED compatibility definitions
 */
#define SBG_VERSION_CMP_THRESOLD_MAJOR              SBG_VERSION_CMP_THRESHOLD_MAJOR
#define SBG_VERSION_CMP_THRESOLD_MINOR              SBG_VERSION_CMP_THRESHOLD_MINOR
#define SBG_VERSION_CMP_THRESOLD_REVISION           SBG_VERSION_CMP_THRESHOLD_REVISION
#define SBG_VERSION_CMP_THRESOLD_BUILD              SBG_VERSION_CMP_THRESHOLD_BUILD
#define SBG_VERSION_CMP_THRESOLD_QUALIFIER          SBG_VERSION_CMP_THRESHOLD_QUALIFIER
 
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)     )
//----------------------------------------------------------------------//
//- Constructor                                                        -//
//----------------------------------------------------------------------//
 
SBG_COMMON_LIB_API void sbgVersionCreateBasic(SbgVersion *pVersion, uint8_t major, uint8_t minor, uint8_t revision, uint8_t build);
 
SBG_COMMON_LIB_API void sbgVersionCreateSoftware(SbgVersion *pVersion, uint8_t major, uint8_t minor, uint16_t build, SbgVersionQualifier qualifier);
 
SBG_COMMON_LIB_API void sbgVersionConstructCopy(SbgVersion *pVersion, const SbgVersion *pOtherVersion);
 
//----------------------------------------------------------------------//
//- 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, SbgVersionCmpThreshold threshold);
 
SBG_COMMON_LIB_API int32_t sbgVersionCompareEncoded(uint32_t versionA, uint32_t versionB, SbgVersionCmpThreshold threshold);
 
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, size_t sizeOfBuffer);
 
SBG_COMMON_LIB_API SbgErrorCode sbgVersionToStringEncoded(uint32_t version, char *pBuffer, size_t sizeOfBuffer);
 
//----------------------------------------------------------------------//
//- String to version methods                                          -//
//----------------------------------------------------------------------//
 
SBG_COMMON_LIB_API SbgErrorCode sbgVersionFromString(const char *pString, SbgVersion *pVersion);
 
SBG_COMMON_LIB_API SbgErrorCode sbgVersionFromStringEncoded(const char *pString, 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;
}
 
 
#ifdef __cplusplus
}
#endif
 
#endif  // SBG_VERSION_H