bs_size_new ()

BSSize
bs_size_new (void);

Creates a new BSSize instance initialized to 0.

[constructor]

bs_size_new_from_bytes ()

BSSize
bs_size_new_from_bytes (uint64_t bytes,
                        int sgn);

Creates a new BSSize instance.

[constructor]

bs_size_new_from_str ()

BSSize
bs_size_new_from_str (const char *size_str,
                      BSError **error);

Creates a new BSSize instance.

[constructor]

bs_size_new_from_size ()

BSSize
bs_size_new_from_size (const BSSize size);

Creates a new instance of BSSize.

[constructor]

bs_size_free ()

void
bs_size_free (BSSize size);

Clears size and frees the allocated resources.

bs_clear_error ()

void
bs_clear_error (BSError **error);

Clears error and frees the allocated resources.

bs_size_get_bytes ()

uint64_t
bs_size_get_bytes (const BSSize size,
                   int *sgn,
                   BSError **error);

Get the number of bytes of the size .

bs_size_sgn ()

int
bs_size_sgn (const BSSize size);

Get the sign of the size.

bs_size_get_bytes_str ()

char *
bs_size_get_bytes_str (const BSSize size);

Get the number of bytes in size as a string. This way, the caller doesn't have to care about the limitations of some particular integer type.

bs_size_convert_to ()

char *
bs_size_convert_to (const BSSize size,
                    BSUnit unit,
                    BSError **error);

Get the size converted to unit as a string representing a floating-point number.

bs_size_human_readable ()

char *
bs_size_human_readable (const BSSize size,
                        BSBunit min_unit,
                        int max_places,
                        bool xlate);

Get a human-readable representation of size .

bs_size_add ()

BSSize
bs_size_add (const BSSize size1,
             const BSSize size2);

Add two sizes.

bs_size_grow ()

BSSize
bs_size_grow (BSSize size1,
              const BSSize size2);

Grows size1 by size2 . IOW, adds size2 to size1 in-place (modifying size1 ).

Basically an in-place variant of bs_size_add().

bs_size_add_bytes ()

BSSize
bs_size_add_bytes (const BSSize size,
                   uint64_t bytes);

Add bytes to the size . To add a negative number of bytes use bs_size_sub_bytes().

bs_size_grow_bytes ()

BSSize
bs_size_grow_bytes (BSSize size,
                    uint64_t bytes);

Grows size by bytes . IOW, adds bytes to size in-place (modifying size ).

Basically an in-place variant of bs_size_add_bytes().

bs_size_sub ()

BSSize
bs_size_sub (const BSSize size1,
             const BSSize size2);

Subtract size2 from size1 .

bs_size_shrink ()

BSSize
bs_size_shrink (BSSize size1,
                const BSSize size2);

Shrinks size1 by size2 . IOW, subtracts size2 from size1 in-place (modifying size1 ).

Basically an in-place variant of bs_size_sub().

bs_size_sub_bytes ()

BSSize
bs_size_sub_bytes (const BSSize size,
                   uint64_t bytes);

Subtract bytes from the size . To subtract a negative number of bytes use bs_size_add_bytes().

bs_size_shrink_bytes ()

BSSize
bs_size_shrink_bytes (BSSize size,
                      uint64_t bytes);

Shrinks size by bytes . IOW, subtracts bytes from size in-place (modifying size ). To shrink by a negative number of bytes use bs_size_grow_bytes().

Basically an in-place variant of bs_size_sub_bytes().

bs_size_mul_int ()

BSSize
bs_size_mul_int (const BSSize size,
                 uint64_t times);

Multiply size by times .

bs_size_grow_mul_int ()

BSSize
bs_size_grow_mul_int (BSSize size,
                      uint64_t times);

Grow size times times. IOW, multiply size by times in-place.

Basically an in-place variant of bs_size_mul_int().

bs_size_mul_float_str ()

BSSize
bs_size_mul_float_str (const BSSize size,
                       const char *float_str,
                       BSError **error);

Multiply size by the floating-point number float_str represents.

bs_size_grow_mul_float_str ()

BSSize
bs_size_grow_mul_float_str (BSSize size,
                            const char *float_str,
                            BSError **error);

Grow size by the floating-point number float_str represents times. IOW, multiply size by float_str in-place.

Basically an in-place variant of bs_size_grow_mul_float_str().

bs_size_div ()

uint64_t
bs_size_div (const BSSize size1,
             const BSSize size2,
             int *sgn,
             BSError **error);

Divide size1 by size2 . Gives the answer to the question "How many times does size2 fit in size1 ?".

bs_size_div_int ()

BSSize
bs_size_div_int (const BSSize size,
                 uint64_t divisor,
                 BSError **error);

Divide size by divisor . Gives the answer to the question "What is the size of each chunk if size is split into a divisor number of pieces?"

Note: Due to the limitations of the current implementation the maximum value divisor is ULONG_MAX (which can differ from UINT64_MAX). An error (BS_ERROR_OVER) is returned if overflow happens.

bs_size_shrink_div_int ()

BSSize
bs_size_shrink_div_int (BSSize size,
                        uint64_t shrink_divisor,
                        BSError **error);

Shrink size by dividing by divisor . IOW, divide size by divisor in-place.

Basically an in-place variant of bs_size_div_int().

Note: Due to the limitations of the current implementation the maximum value divisor is ULONG_MAX (which can differ from UINT64_MAX). An error (BS_ERROR_OVER) is returned if overflow happens.

bs_size_true_div ()

char *
bs_size_true_div (const BSSize size1,
                  const BSSize size2,
                  BSError **error);

Divides size1 by size2 .

bs_size_true_div_int ()

char *
bs_size_true_div_int (const BSSize size,
                      uint64_t divisor,
                      BSError **error);

Divides size by divisor .

Note: Due to the limitations of the current implementation the maximum value divisor is ULONG_MAX (which can differ from UINT64_MAX). An error (BS_ERROR_OVER) is returned if overflow happens.

bs_size_mod ()

BSSize
bs_size_mod (const BSSize size1,
             const BSSize size2,
             BSError **error);

Gives size1 modulo size2 (i.e. the remainder of integer division size1 / size2 ). Gives the answer to the question "If I split size1 into chunks of size size2 , what will be the remainder?" **This function ignores the signs of the sizes.**

bs_size_round_to_nearest ()

BSSize
bs_size_round_to_nearest (const BSSize size,
                          const BSSize round_to,
                          BSRoundDir dir,
                          BSError **error);

Round size to the nearest multiple of round_to according to the direction given by dir .

bs_size_cmp ()

int
bs_size_cmp (const BSSize size1,
             const BSSize size2,
             bool abs);

Compare size1 and size2 . This function behaves like the standard *cmp*() functions.

bs_size_cmp_bytes ()

int
bs_size_cmp_bytes (const BSSize size1,
                   uint64_t bytes,
                   bool abs);

Compare size and bytes , i.e. the number of bytes size has with bytes . This function behaves like the standard *cmp*() functions.

BSSize

typedef struct _BSSize * BSSize;

An opaque type representing a size in bytes.

enum BSErrorCode

Error codes that identify various errors that can occur while working with BSSize instances.

BSError

typedef struct {
    BSErrorCode code;
    char *msg;
} BSError;

enum BSBunit

Binary units (multiples of 1024) of size in bytes.

enum BSDunit

Decimal units (multiples of 1000) of size in bytes.

enum BSRoundDir

Rounding direction for rounding operations.

BSUnit

Generic unit fo size in bytes.

BS_FLOAT_PREC_BITS

#define BS_FLOAT_PREC_BITS 256

Precision (in bits) of floating-point numbers used internally.