include/a/version.h

   1 /*!
   2  @file version.h
   3  @brief algorithm library version
   4 */
   5
   6 #ifndef LIBA_VERSION_H
   7 #define LIBA_VERSION_H
   8
   9 #include "a.h"
  10
  11 /*!
  12  @ingroup A
  13  @addtogroup A_VERSION algorithm library version
  14  @{
  15 */
  16
  17 /*! algorithm library version major */
  18 #ifndef A_VERSION_MAJOR
  19 #define A_VERSION_MAJOR 0
  20 #endif /* A_VERSION_MAJOR */
  21 #undef major
  22
  23 /*! algorithm library version minor */
  24 #ifndef A_VERSION_MINOR
  25 #define A_VERSION_MINOR 1
  26 #endif /* A_VERSION_MINOR */
  27 #undef minor
  28
  29 /*! algorithm library version patch */
  30 #ifndef A_VERSION_PATCH
  31 #define A_VERSION_PATCH 6
  32 #endif /* A_VERSION_PATCH */
  33 #undef patch
  34
  35 /*! algorithm library version tweak */
  36 #ifndef A_VERSION_TWEAK
  37 #define A_VERSION_TWEAK 20240229
  38 #endif /* A_VERSION_TWEAK */
  39
  40 #define A_VERSION_TOSTR(X) A_CAST_1(X)
  41 /*! algorithm library version string */
  42 #ifndef A_VERSION
  43 #define A_VERSION A_VERSION_TOSTR(A_VERSION_MAJOR) "." A_VERSION_TOSTR(A_VERSION_MINOR) "." A_VERSION_TOSTR(A_VERSION_PATCH)
  44 #endif /* A_VERSION */
  45
  46 typedef struct a_version a_version;
  47 // clang-format off
  48 #if defined(__cplusplus)
  49 #define A_VERSION_C(major, minor, third) {major, minor, third, 0}
  50 #define A_VERSION_EX(major, minor, third, extra) {major, minor, third, extra}
  51 #else /* !__cplusplus */
  52 #define A_VERSION_C(major, minor, third) (a_version){major, minor, third, 0}
  53 #define A_VERSION_EX(major, minor, third, extra) (a_version){major, minor, third, extra}
  54 #endif /* __cplusplus */
  55 // clang-format on
  56
  57 #if defined(__cplusplus)
  58 namespace a
  59 {
  60 typedef a_version version;
  61 } /* namespace a */
  62 extern "C" {
  63 #endif /* __cplusplus */
  64
  65 /*! algorithm library version major */
  66 A_EXTERN unsigned int const a_version_major;
  67 /*! algorithm library version minor */
  68 A_EXTERN unsigned int const a_version_minor;
  69 /*! algorithm library version patch */
  70 A_EXTERN unsigned int const a_version_patch;
  71 /*! algorithm library version tweak */
  72 A_EXTERN a_u32 const a_version_tweak;
  73
  74 /*!
  75  @brief algorithm library version check
  76  @param[in] major required major number
  77  @param[in] minor required minor number
  78  @param[in] patch required patch number
  79  @return result of comparison
  80   @retval <0 library version is higher than required version
  81   @retval >0 library version is lower than required version
  82   @retval 0 library version is equal to required version
  83 */
  84 A_EXTERN int a_version_check(unsigned int major, unsigned int minor, unsigned int patch);
  85 #define a_version_check() a_version_check(A_VERSION_MAJOR, A_VERSION_MINOR, A_VERSION_PATCH)
  86
  87 /*!
  88  @brief compare the version lhs with the version rhs
  89  @param[in] lhs version structure to be compared
  90  @param[in] rhs version structure to be compared
  91  @return relationship between the versions
  92   @retval <0 version lhs < version rhs
  93   @retval >0 version lhs > version rhs
  94   @retval 0 version lhs == version rhs
  95 */
  96 A_EXTERN int a_version_cmp(a_version const *lhs, a_version const *rhs);
  97
  98 /*!
  99  @brief version lhs is less than version rhs
 100  @param[in] lhs operand on the left
 101  @param[in] rhs operand on the right
 102  @return result of comparison
 103 */
 104 A_EXTERN a_bool a_version_lt(a_version const *lhs, a_version const *rhs);
 105
 106 /*!
 107  @brief version lhs is greater than version rhs
 108  @param[in] lhs operand on the left
 109  @param[in] rhs operand on the right
 110  @return result of comparison
 111 */
 112 A_EXTERN a_bool a_version_gt(a_version const *lhs, a_version const *rhs);
 113
 114 /*!
 115  @brief version lhs is less than or equal to version rhs
 116  @param[in] lhs operand on the left
 117  @param[in] rhs operand on the right
 118  @return result of comparison
 119 */
 120 A_EXTERN a_bool a_version_le(a_version const *lhs, a_version const *rhs);
 121
 122 /*!
 123  @brief version lhs is greater than or equal to version rhs
 124  @param[in] lhs operand on the left
 125  @param[in] rhs operand on the right
 126  @return result of comparison
 127 */
 128 A_EXTERN a_bool a_version_ge(a_version const *lhs, a_version const *rhs);
 129
 130 /*!
 131  @brief version lhs is equal to version rhs
 132  @param[in] lhs operand on the left
 133  @param[in] rhs operand on the right
 134  @return result of comparison
 135 */
 136 A_EXTERN a_bool a_version_eq(a_version const *lhs, a_version const *rhs);
 137
 138 /*!
 139  @brief version lhs is not equal to version rhs
 140  @param[in] lhs operand on the left
 141  @param[in] rhs operand on the right
 142  @return result of comparison
 143 */
 144 A_EXTERN a_bool a_version_ne(a_version const *lhs, a_version const *rhs);
 145
 146 /*!
 147  @brief algorithm library version parse
 148  @param[in,out] ctx points to an instance structure for version
 149  @param[in] ver version string to be parsed
 150  @return number of parsed characters
 151 */
 152 A_EXTERN unsigned int a_version_parse(a_version *ctx, char const *ver);
 153
 154 #if defined(__cplusplus)
 155 } /* extern "C" */
 156 #endif /* __cplusplus */
 157
 158 /*!
 159  @brief instance structure for version
 160 */
 161 struct a_version
 162 {
 163     unsigned int major; //!< major number
 164     unsigned int minor; //!< minor number
 165     unsigned int third; //!< third number
 166     unsigned int extra; //!< extra number
 167 #if defined(__cplusplus)
 168     A_INLINE int cmp(a_version const &ver) const
 169     {
 170         return a_version_cmp(this, &ver);
 171     }
 172     A_INLINE bool operator<(a_version const &ver) const
 173     {
 174         return a_version_lt(this, &ver);
 175     }
 176     A_INLINE bool operator>(a_version const &ver) const
 177     {
 178         return a_version_gt(this, &ver);
 179     }
 180     A_INLINE bool operator<=(a_version const &ver) const
 181     {
 182         return a_version_le(this, &ver);
 183     }
 184     A_INLINE bool operator>=(a_version const &ver) const
 185     {
 186         return a_version_ge(this, &ver);
 187     }
 188     A_INLINE bool operator==(a_version const &ver) const
 189     {
 190         return a_version_eq(this, &ver);
 191     }
 192     A_INLINE bool operator!=(a_version const &ver) const
 193     {
 194         return a_version_ne(this, &ver);
 195     }
 196     A_INLINE unsigned int parse(char const *ver)
 197     {
 198         return a_version_parse(this, ver);
 199     }
 200     /*! algorithm library version major */
 201     A_PUBLIC static unsigned int const MAJOR;
 202     /*! algorithm library version minor */
 203     A_PUBLIC static unsigned int const MINOR;
 204     /*! algorithm library version patch */
 205     A_PUBLIC static unsigned int const PATCH;
 206     /*! algorithm library version tweak */
 207     A_PUBLIC static a_u32 const TWEAK;
 208 #endif /* __cplusplus */
 209 };
 210
 211 /*! @} A_VERSION */
 212
 213 #endif /* a/version.h */