diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 09:55:11 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 09:55:11 +0000 |
commit | cd07912073c951b4bbb871ed2653af1be2cfc714 (patch) | |
tree | 1073c2308492e6aea4c66cb7436ee92db2abfd42 /src/plugins_types/decimal64.c | |
parent | Initial commit. (diff) | |
download | libyang2-upstream/2.1.30.tar.xz libyang2-upstream/2.1.30.zip |
Adding upstream version 2.1.30.upstream/2.1.30upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/plugins_types/decimal64.c')
-rw-r--r-- | src/plugins_types/decimal64.c | 239 |
1 files changed, 239 insertions, 0 deletions
diff --git a/src/plugins_types/decimal64.c b/src/plugins_types/decimal64.c new file mode 100644 index 0000000..25a88d9 --- /dev/null +++ b/src/plugins_types/decimal64.c @@ -0,0 +1,239 @@ +/** + * @file decimal64.c + * @author Radek Krejci <rkrejci@cesnet.cz> + * @brief Built-in decimal64 type plugin. + * + * Copyright (c) 2019-2021 CESNET, z.s.p.o. + * + * This source code is licensed under BSD 3-Clause License (the "License"). + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + */ + +#include "plugins_types.h" + +#include <stdint.h> +#include <stdlib.h> + +#include "libyang.h" + +/* additional internal headers for some useful simple macros */ +#include "common.h" +#include "compat.h" +#include "plugins_internal.h" /* LY_TYPE_*_STR */ + +/** + * @page howtoDataLYB LYB Binary Format + * @subsection howtoDataLYBTypesDecimal64 decimal64 (built-in) + * + * | Size (B) | Mandatory | Type | Meaning | + * | :------ | :-------: | :--: | :-----: | + * | 8 | yes | `int64_t *` | little-endian value represented without floating point | + */ + +/** + * @brief Convert decimal64 number to canonical string. + * + * @param[in] num Decimal64 number stored in int64. + * @param[in] type Decimal64 type with fraction digits. + * @param[out] str Canonical string value. + * @return LY_ERR value. + */ +static LY_ERR +decimal64_num2str(int64_t num, struct lysc_type_dec *type, char **str) +{ + char *ret; + + /* allocate the value */ + ret = calloc(1, LY_NUMBER_MAXLEN); + LY_CHECK_RET(!ret, LY_EMEM); + + if (num) { + int count = sprintf(ret, "%" PRId64 " ", num); + + if (((num > 0) && ((count - 1) <= type->fraction_digits)) || ((count - 2) <= type->fraction_digits)) { + /* we have 0. value, print the value with the leading zeros + * (one for 0. and also keep the correct with of num according + * to fraction-digits value) + * for (num < 0) - extra character for '-' sign */ + count = sprintf(ret, "%0*" PRId64 " ", (num > 0) ? (type->fraction_digits + 1) : (type->fraction_digits + 2), num); + } + for (uint8_t i = type->fraction_digits, j = 1; i > 0; i--) { + if (j && (i > 1) && (ret[count - 2] == '0')) { + /* we have trailing zero to skip */ + ret[count - 1] = '\0'; + } else { + j = 0; + ret[count - 1] = ret[count - 2]; + } + count--; + } + ret[count - 1] = '.'; + } else { + /* zero */ + sprintf(ret, "0.0"); + } + + *str = ret; + return LY_SUCCESS; +} + +LIBYANG_API_DEF LY_ERR +lyplg_type_store_decimal64(const struct ly_ctx *ctx, const struct lysc_type *type, const void *value, size_t value_len, + uint32_t options, LY_VALUE_FORMAT format, void *UNUSED(prefix_data), uint32_t hints, + const struct lysc_node *UNUSED(ctx_node), struct lyd_value *storage, struct lys_glob_unres *UNUSED(unres), + struct ly_err_item **err) +{ + struct lysc_type_dec *type_dec = (struct lysc_type_dec *)type; + LY_ERR ret = LY_SUCCESS; + int64_t num; + char *canon; + + /* init storage */ + memset(storage, 0, sizeof *storage); + storage->realtype = type; + + if (format == LY_VALUE_LYB) { + /* validation */ + if (value_len != 8) { + ret = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "Invalid LYB decimal64 value size %zu (expected 8).", + value_len); + goto cleanup; + } + + /* we have the decimal64 number, in host byte order */ + memcpy(&num, value, value_len); + num = le64toh(num); + } else { + /* check hints */ + ret = lyplg_type_check_hints(hints, value, value_len, type->basetype, NULL, err); + LY_CHECK_GOTO(ret, cleanup); + + /* parse decimal64 value */ + ret = lyplg_type_parse_dec64(type_dec->fraction_digits, value, value_len, &num, err); + LY_CHECK_GOTO(ret, cleanup); + } + + /* store value */ + storage->dec64 = num; + + /* we need canonical value for the range check */ + if (format == LY_VALUE_CANON) { + /* store canonical value */ + if (options & LYPLG_TYPE_STORE_DYNAMIC) { + ret = lydict_insert_zc(ctx, (char *)value, &storage->_canonical); + options &= ~LYPLG_TYPE_STORE_DYNAMIC; + LY_CHECK_GOTO(ret, cleanup); + } else { + ret = lydict_insert(ctx, value, value_len, &storage->_canonical); + LY_CHECK_GOTO(ret, cleanup); + } + } else { + /* generate canonical value */ + ret = decimal64_num2str(num, type_dec, &canon); + LY_CHECK_GOTO(ret, cleanup); + + /* store it */ + ret = lydict_insert_zc(ctx, canon, (const char **)&storage->_canonical); + LY_CHECK_GOTO(ret, cleanup); + } + + if (type_dec->range) { + /* check range of the number */ + ret = lyplg_type_validate_range(type->basetype, type_dec->range, num, storage->_canonical, + strlen(storage->_canonical), err); + LY_CHECK_GOTO(ret, cleanup); + } + +cleanup: + if (options & LYPLG_TYPE_STORE_DYNAMIC) { + free((void *)value); + } + + if (ret) { + lyplg_type_free_simple(ctx, storage); + } + return ret; +} + +LIBYANG_API_DEF LY_ERR +lyplg_type_compare_decimal64(const struct lyd_value *val1, const struct lyd_value *val2) +{ + if (val1->realtype != val2->realtype) { + return LY_ENOT; + } + + /* if type is the same, the fraction digits are, too */ + if (val1->dec64 != val2->dec64) { + return LY_ENOT; + } + return LY_SUCCESS; +} + +LIBYANG_API_DEF const void * +lyplg_type_print_decimal64(const struct ly_ctx *UNUSED(ctx), const struct lyd_value *value, LY_VALUE_FORMAT format, + void *UNUSED(prefix_data), ly_bool *dynamic, size_t *value_len) +{ + int64_t num = 0; + void *buf; + + if (format == LY_VALUE_LYB) { + num = htole64(value->dec64); + if (num == value->dec64) { + /* values are equal, little-endian */ + *dynamic = 0; + if (value_len) { + *value_len = sizeof value->dec64; + } + return &value->dec64; + } else { + /* values differ, big-endian */ + buf = calloc(1, sizeof value->dec64); + LY_CHECK_RET(!buf, NULL); + + *dynamic = 1; + if (value_len) { + *value_len = sizeof value->dec64; + } + memcpy(buf, &num, sizeof value->dec64); + return buf; + } + } + + /* use the cached canonical value */ + if (dynamic) { + *dynamic = 0; + } + if (value_len) { + *value_len = strlen(value->_canonical); + } + return value->_canonical; +} + +/** + * @brief Plugin information for decimal64 type implementation. + * + * Note that external plugins are supposed to use: + * + * LYPLG_TYPES = { + */ +const struct lyplg_type_record plugins_decimal64[] = { + { + .module = "", + .revision = NULL, + .name = LY_TYPE_DEC64_STR, + + .plugin.id = "libyang 2 - decimal64, version 1", + .plugin.store = lyplg_type_store_decimal64, + .plugin.validate = NULL, + .plugin.compare = lyplg_type_compare_decimal64, + .plugin.sort = NULL, + .plugin.print = lyplg_type_print_decimal64, + .plugin.duplicate = lyplg_type_dup_simple, + .plugin.free = lyplg_type_free_simple, + .plugin.lyb_data_len = 8, + }, + {0} +}; |