Baillehache Pascal's personal website

LibCapy - range

Class to implement range of value.

Macros:

#define CAPY_RANGE_H

#define CapyDecRange(name, type)                                      \
typedef struct CapyRange ## name CapyRange ## name;                   \
struct CapyRange ## name {                                            \
  union {                                                             \
    type vals[2];                                                     \
    struct __attribute__((packed)) {type min, max;};                  \
  };                                                                  \
  CapyPad(type[2], 0);                                                \
  void (*destruct)(void);                                             \
  type (*trim)(type const val);                                       \
  void (*clip)(CapyRange ## name const* const range);                 \
};                                                                    \
CapyRange ## name CapyRange ## name ## Create(                        \
  type const min,                                                     \
  type const max);                                                    \
CapyRange ## name* CapyRange ## name ## Alloc(                        \
  type const min,                                                     \
  type const max);                                                    \
void CapyRange ## name ## Destruct(void);                             \
void CapyRange ## name ## Free(CapyRange ## name** const that);       \
type CapyRange ## name ## Trim(type const val);                       \
void CapyRange ## name ## Clip(CapyRange ## name const* const range);

Range object. Declaration macro for a range of values of type 'type' and name 'name'

#define CapyDefRangeCreate(name, type)           \
CapyRange ## name CapyRange ## name ## Create(   \
  type const min,                                \
  type const max) {                              \
  CapyRange ## name that = {0};                  \
  that.vals[0] = min;                            \
  that.vals[1] = max;                            \
  that.destruct = CapyRange ## name ## Destruct; \
  that.trim = CapyRange ## name ## Trim;         \
  that.clip = CapyRange ## name ## Clip;         \
  return that;                                   \
}

Create a new CapyRange

Input argument(s):

min: the lower value of the range
max: the upper value of the range

Output and side effect(s):

Return a new CapyRange

#define CapyDefRangeAlloc(name, type)            \
CapyRange ## name* CapyRange ## name ## Alloc(   \
  type const min,                                \
  type const max) {                              \
  CapyRange ## name* that = NULL;                \
  safeMalloc(that, 1);                           \
  if(!that) return NULL;                         \
  *that = CapyRange ## name ## Create(min, max); \
  return that;                                   \
}

Create a newly allocated CapyRange

Input argument(s):

min: the lower value of the range
max: the upper value of the range

Output and side effect(s):

Return a newly allocated CapyRange

Exception(s):

May raise CapyExc_MallocFailed

#define CapyDefRangeDestruct(name, type)   \
void CapyRange ## name ## Destruct(void) { \
  return;                                  \
}

Free the memory used by a CapyRange

Input argument(s):

that: the CapyRange to free

#define CapyDefRangeFree(name, type)                             \
void CapyRange ## name ## Free(CapyRange ## name** const that) { \
  if(that == NULL || *that == NULL) return;                      \
  $(*that, destruct)();                                          \
  free(*that);                                                   \
  *that = NULL;                                                  \
}

Free the memory used by a pointer to a CapyRange and reset '*that' to NULL

Input argument(s):

that: a pointer to the CapyRange to free

#define CapyDefRangeTrim(name, type)                      \
type CapyRange ## name ## Trim(type const val) {          \
  CapyRange ## name* that = (CapyRange ## name*)capyThat; \
  return (val < that->vals[0] ? that->vals[0] :           \
          val > that->vals[1] ? that->vals[1] : val);     \
}

Trim a value to a CapyRange interval

Input argument(s):

val: the value to trim

Output and side effect(s):

Returned the value trimmed to the interval of the range

#define CapyDefRangeClip(name, type)                                   \
void CapyRange ## name ## Clip(CapyRange ## name const* const range) { \
  CapyRange ## name* that = (CapyRange ## name*)capyThat;              \
  if(range != NULL) {                                                  \
    if(that->min < range->min) that->min = range->min;                 \
    if(that->max > range->max) that->max = range->max;                 \
  }                                                                    \
}

Clip the range to with another

Input argument(s):

range: the other range

Output and side effect(s):

The range is modified to the intersection of the range and the other range. max < min means the intersection is empty

#define CapyDefRange(name, type)   \
  CapyDefRangeCreate(name, type)   \
  CapyDefRangeAlloc(name, type)    \
  CapyDefRangeDestruct(name, type) \
  CapyDefRangeFree(name, type)     \
  CapyDefRangeTrim(name, type)     \
  CapyDefRangeClip(name, type)

Definition macro calling all the submacros at once for a range object

Enumerations:

None.

Typedefs:

None.

Functions:

None.

2021-11-24
in LibCapy,
70 views