forked from CESNET/libyang
-
Notifications
You must be signed in to change notification settings - Fork 0
/
plugins_types.h
1055 lines (942 loc) · 48.4 KB
/
plugins_types.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/**
* @file plugins_types.h
* @author Radek Krejci <rkrejci@cesnet.cz>
* @brief API for (user) types plugins
*
* Copyright (c) 2019 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
*/
#ifndef LY_PLUGINS_TYPES_H_
#define LY_PLUGINS_TYPES_H_
#include <stddef.h>
#include <stdint.h>
#include "log.h"
#include "plugins.h"
#include "tree.h"
#include "tree_edit.h"
#ifdef __cplusplus
extern "C" {
#endif
struct ly_ctx;
struct ly_path;
struct lyd_node;
struct lyd_value;
struct lys_module;
struct lys_glob_unres;
struct lysc_ident;
struct lysc_node;
struct lysc_pattern;
struct lysc_range;
struct lysc_type;
struct lysc_type_leafref;
/**
* @page howtoPluginsTypes Type Plugins
*
* Note that the part of the libyang API here is available only by including a separated `<libyang/plugins_types.h>` header
* file. Also note that the type plugins API is versioned separately from libyang itself, so backward incompatible changes
* can come even without changing libyang major version.
*
* YANG allows to define new data types via *typedef* statements or even in leaf's/leaf-list's *type* statements.
* Such types are derived (directly or indirectly) from a set of [YANG built-in types](https://tools.ietf.org/html/rfc7950#section-4.2.4).
* libyang implements all handling of the data values of the YANG types via the Type Plugins API. Internally, there is
* implementation of the built-in types and others can be added as an external plugin (see @ref howtoPlugins).
*
* Type plugin is supposed to
* - store (and canonize) data value,
* - validate it according to the type's restrictions,
* - compare two values (::lyd_value) of the same type,
* - duplicate value (::lyd_value),
* - print it and
* - free the specific data inserted into ::lyd_value.
*
* These tasks are implemented as callbacks provided to libyang via ::lyplg_type_record structures defined as array using
* ::LYPLG_TYPES macro.
*
* All the callbacks are supposed to do not log directly via libyang logger. Instead, they return ::LY_ERR value and
* ::ly_err_item error structure(s) describing the detected error(s) (helper functions ::ly_err_new() and ::ly_err_free()
* are available).
*
* The main functionality is provided via ::lyplg_type_store_clb callback responsible for canonizing and storing
* provided string representation of the value in specified format (XML and JSON supported). Valid value is stored in
* ::lyd_value structure - its union allows to store data as one of the predefined type or in a custom form behind
* the void *ptr member of ::lyd_value structure. The callback is also responsible for storing canonized string
* representation of the value as ::lyd_value._canonical. If the type does not define canonical representation, the original
* representation is stored. In case there are any differences between the representation in specific input types, the plugin
* is supposed to store the value in JSON representation - typically, the difference is in prefix representation and JSON
* format uses directly the module names as prefixes.
*
* Usually, all the validation according to the type's restrictions is done in the store callback. However, in case the type
* requires some validation referencing other entities in the data tree, the optional validation callback
* ::lyplg_type_validate_clb can be implemented.
*
* The stored values can be compared in a specific way by providing ::lyplg_type_compare_clb. In case the best way to compare
* the values is to compare their canonical string representations, the ::lyplg_type_compare_simple() function can be used.
*
* Data duplication is done with ::lyplg_type_dup_clb callbacks. Note that the callback is responsible even for duplicating
* the ::lyd_value._canonical, so the callback must be always present (the canonical value is always present). If there is
* nothing else to duplicate, the plugin can use the generic ::lyplg_type_dup_simple().
*
* The stored value can be printed into the required format via ::lyplg_type_print_clb implementation. Simple printing
* canonical representation of the value is implemented by ::lyplg_type_print_simple().
*
* And finally freeing any data stored in the ::lyd_value by the plugin is done by implementation of ::lyplg_type_free_clb.
* Freeing only the canonical string is implemented by ::lyplg_type_free_simple().
*
* The plugin information contains also the plugin identifier (::lyplg_type.id). This string can serve to identify the
* specific plugin responsible to storing data value. In case the user can recognize the id string, it can access the
* plugin specific data with the appropriate knowledge of its structure.
*
* Besides the mentioned `_simple` functions, libyang provides, as part of the type plugins API, all the callbacks
* implementing the built-in types in the internal plugins:
*
* - [simple callbacks](@ref pluginsTypesSimple) handling only the canonical strings in the value,
* - [binary built-in type](@ref pluginsTypesBinary)
* - [bits built-in type](@ref pluginsTypesBits)
* - [boolean built-in type](@ref pluginsTypesBoolean)
* - [decimal64 built-in type](@ref pluginsTypesDecimal64)
* - [empty built-in type](@ref pluginsTypesEmpty)
* - [enumeration built-in type](@ref pluginsTypesEnumeration)
* - [identityref built-in type](@ref pluginsTypesIdentityref)
* - [instance-identifier built-in type](@ref pluginsTypesInstanceid)
* - [integer built-in types](@ref pluginsTypesInteger)
* - [leafref built-in type](@ref pluginsTypesLeafref)
* - [string built-in type](@ref pluginsTypesString)
* - [union built-in type](@ref pluginsTypesUnion)
*
* And one derived type:
*
* - [xpath1.0 `ietf-yang-types` type](@ref pluginsTypesXpath10)
*
* In addition to these callbacks, the API also provides several functions which can help to implement your own plugin for the
* derived YANG types:
*
* - ::ly_err_new()
* - ::ly_err_free()
*
* - ::lyplg_type_lypath_new()
* - ::lyplg_type_lypath_free()
*
* - ::lyplg_type_prefix_data_new()
* - ::lyplg_type_prefix_data_dup()
* - ::lyplg_type_prefix_data_free()
* - ::lyplg_type_get_prefix()
*
* - ::lyplg_type_check_hints()
* - ::lyplg_type_identity_isderived()
* - ::lyplg_type_identity_module()
* - ::lyplg_type_make_implemented()
* - ::lyplg_type_parse_dec64()
* - ::lyplg_type_parse_int()
* - ::lyplg_type_parse_uint()
* - ::lyplg_type_resolve_leafref()
*/
/**
* @defgroup pluginsTypes Plugins: Types
* @{
*
* Structures and functions to for libyang plugins implementing specific YANG types defined in YANG modules. For more
* information, see @ref howtoPluginsTypes.
*
* This part of libyang API is available by including `<libyang/plugins_types.h>` header file.
*/
/**
* @brief Extensions API version
*/
#define LYPLG_TYPE_API_VERSION 1
/**
* @brief Macro to define plugin information in external plugins
*
* Use as follows:
* LYPLG_TYPES = {{<filled information of ::lyplg_type_record>}, ..., {0}};
*/
#define LYPLG_TYPES \
uint32_t plugins_types_apiver__ = LYPLG_TYPE_API_VERSION; \
const struct lyplg_type_record plugins_types__[]
/**
* @brief Create and fill error structure.
*
* Helper function for various plugin functions to generate error information structure.
*
* @param[in, out] err Pointer to store a new error structure filled according to the input parameters. If the storage
* already contains error information, the new record is appended into the errors list.
* @param[in] ecode Code of the error to fill. In case LY_SUCCESS value, nothing is done and LY_SUCCESS is returned.
* @param[in] vecode Validity error code in case of LY_EVALID error code.
* @param[in] path Path to the node causing the error.
* @param[in] apptag Error-app-tag value.
* @param[in] err_msg error formating message.
* @return The given @p ecode value if the @p err is successfully created. The structure can be freed using ::ly_err_free()
* or passed back from callback into libyang.
* @return LY_EMEM If there is not enough memory for allocating error record, the @p err is not touched in that case.
* @return LY_SUCCESS if @p ecode is LY_SUCCESS, the @p err is not touched in this case.
*/
LY_ERR ly_err_new(struct ly_err_item **err, LY_ERR ecode, LY_VECODE vecode, char *path, char *apptag, const char *err_msg, ...);
/**
* @brief Destructor for the error records created with ::ly_err_new().
*
* Compatible with the free(), so usable as a generic callback.
*
* @param[in] ptr Error record (::ly_err_item, the void pointer is here only for compatibility with a generic free()
* function) to free. With the record, also all the records (if any) connected after this one are freed.
*/
void ly_err_free(void *ptr);
/**
* @brief Check that the type is suitable for the parser's hints (if any) in the specified format
*
* Use only in implementations of ::lyplg_type_store_clb which provide all the necessary parameters for this function.
*
* @param[in] hints Bitmap of [value hints](@ref lydvalhints) of all the allowed value types provided by parsers
* to ::lyplg_type_store_clb.
* @param[in] value Lexical representation of the value to be stored.
* @param[in] value_len Length (number of bytes) of the given \p value.
* @param[in] type Expected base type of the @p value by the caller.
* @param[out] base Pointer to store the numeric base for parsing numeric values using strtol()/strtoll() function.
* Returned (and required) only for numeric @p type values.
* @param[out] err Pointer to store error information in case of failure.
* @return LY_ERR value
*/
LY_ERR lyplg_type_check_hints(uint32_t hints, const char *value, size_t value_len, LY_DATA_TYPE type, int *base,
struct ly_err_item **err);
/**
* @brief Get the corresponding module for the identity value.
*
* Use only in implementations of ::lyplg_type_store_clb which provide all the necessary parameters for this function.
*
* @param[in] ctx libyang context.
* @param[in] ctx_node Schema node where the value is instantiated to determine the module in case of unprefixed value
* in specific @p format.
* @param[in] prefix Prefix to resolve - identified beginning of a prefix in ::lyplg_type_store_clb's value parameter.
* If NULL, an unprefixed identity is resolved.
* @param[in] prefix_len Length of @p prefix.
* @param[in] format Format of the prefix (::lyplg_type_store_clb's format parameter).
* @param[in] prefix_data Format-specific data (::lyplg_type_store_clb's prefix_data parameter).
* @return Resolved prefix module,
* @return NULL otherwise.
*/
const struct lys_module *lyplg_type_identity_module(const struct ly_ctx *ctx, const struct lysc_node *ctx_node,
const char *prefix, size_t prefix_len, LY_VALUE_FORMAT format, const void *prefix_data);
/**
* @brief Implement a module (just like ::lys_set_implemented()), but keep maintaining unresolved items.
*
* Use only in implementations of ::lyplg_type_store_clb which provide all the necessary parameters for this function.
*
* @param[in] mod Module to implement.
* @param[in] features Array of features to enable.
* @param[in,out] unres Global unres to add to.
* @return LY_ERR value.
*/
LY_ERR lyplg_type_make_implemented(struct lys_module *mod, const char **features, struct lys_glob_unres *unres);
/**
* @brief Get format-specific prefix for a module.
*
* Use only in implementations of ::lyplg_type_print_clb which provide all the necessary parameters for this function.
*
* @param[in] mod Module whose prefix to get - the module somehow connected with the value to print.
* @param[in] format Format of the prefix (::lyplg_type_print_clb's format parameter).
* @param[in] prefix_data Format-specific data (::lyplg_type_print_clb's prefix_data parameter).
* @return Module's prefix to print.
* @return NULL on error.
*/
const char *lyplg_type_get_prefix(const struct lys_module *mod, LY_VALUE_FORMAT format, void *prefix_data);
/**
* @brief Store used prefixes in a string into an internal libyang structure used in ::lyd_value.
*
* Use only in implementations of ::lyplg_type_store_clb which provide all the necessary parameters for this function.
*
* If @p prefix_data_p are non-NULL, they are treated as valid according to the @p format_p and new possible
* prefixes are simply added. This way it is possible to store prefix data for several strings together.
*
* @param[in] ctx libyang context.
* @param[in] value Value to be parsed.
* @param[in] value_len Length of @p value.
* @param[in] format Format of the prefixes in the value.
* @param[in] prefix_data Format-specific data for resolving any prefixes (see ly_resolve_prefix()).
* @param[in,out] format_p Resulting format of the prefixes.
* @param[in,out] prefix_data_p Resulting prefix data for the value in format @p format_p.
* @return LY_ERR value.
*/
LY_ERR lyplg_type_prefix_data_new(const struct ly_ctx *ctx, const void *value, size_t value_len, LY_VALUE_FORMAT format,
const void *prefix_data, LY_VALUE_FORMAT *format_p, void **prefix_data_p);
/**
* @brief Duplicate prefix data.
*
* Use only in implementations of ::lyplg_type_store_clb which provide all the necessary parameters for this function.
*
* @param[in] ctx libyang context.
* @param[in] format Format of the prefixes in the value.
* @param[in] orig Prefix data to duplicate.
* @param[out] dup Duplicated prefix data.
* @return LY_ERR value.
*/
LY_ERR lyplg_type_prefix_data_dup(const struct ly_ctx *ctx, LY_VALUE_FORMAT format, const void *orig, void **dup);
/**
* @brief Free internal prefix data.
*
* Use only in implementations of ::lyplg_type_store_clb which provide all the necessary parameters for this function.
*
* @param[in] format Format of the prefixes.
* @param[in] prefix_data Format-specific data to free.
*/
void lyplg_type_prefix_data_free(LY_VALUE_FORMAT format, void *prefix_data);
/**
* @brief Helper function to create internal schema path representation for instance-identifier value representation.
*
* Use only in implementations of ::lyplg_type_store_clb which provide all the necessary parameters for this function.
*
* @param[in] ctx libyang Context
* @param[in] value Lexical representation of the value to be stored.
* @param[in] value_len Length (number of bytes) of the given \p value.
* @param[in] options [Type plugin store options](@ref plugintypestoreopts).
* @param[in] format Input format of the value.
* @param[in] prefix_data Format-specific data for resolving any prefixes (see ly_resolve_prefix()).
* @param[in] ctx_node The @p value schema context node.
* @param[in,out] unres Global unres structure for newly implemented modules.
* @param[out] path Pointer to store the created structure representing the schema path from the @p value.
* @param[out] err Pointer to store the error information provided in case of failure.
* @return LY_SUCCESS on success,
* @return LY_ERR value on error.
*/
LY_ERR lyplg_type_lypath_new(const struct ly_ctx *ctx, const char *value, size_t value_len, uint32_t options,
LY_VALUE_FORMAT format, void *prefix_data, const struct lysc_node *ctx_node,
struct lys_glob_unres *unres, struct ly_path **path, struct ly_err_item **err);
/**
* @brief Free ly_path structure used by instanceid value representation.
*
* The ly_path representation can be created by ::lyplg_type_lypath_new().
*
* @param[in] ctx libyang context.
* @param[in] path The structure ([sized array](@ref sizedarrays)) to free.
*/
void lyplg_type_lypath_free(const struct ly_ctx *ctx, struct ly_path *path);
/**
* @defgroup plugintypestoreopts Plugins: Type store callback options.
*
* Options applicable to ::lyplg_type_store_clb().
*
* @{
*/
#define LYPLG_TYPE_STORE_DYNAMIC 0x01 /**< String value was dynamically allocated and is supposed to be freed or
directly inserted into the context's dictionary (e.g. in case of canonization).
In any case, the caller of the callback does not free the provided string
value after calling the type's store callback with this option */
#define LYPLG_TYPE_STORE_IMPLEMENT 0x02 /**< If a foreign module is needed to be implemented to successfully instantiate
the value, make the module implemented. */
/** @} plugintypestoreopts */
/**
* @brief Callback to store the given @p value according to the given @p type.
*
* Value must always be correctly stored meaning all the other type callbacks (such as print or compare)
* must function as expected. However, ::lyd_value._canonical can be left NULL and will be generated
* and stored on-demand. But if @p format is ::LY_VALUE_CANON (or another, which must be equal to the canonical
* value), the canonical value should be stored so that it does not have to be generated later.
*
* Note that the @p value is not necessarily zero-terminated. The provided @p value_len is always correct.
* All store functions have to free a dynamically allocated @p value in all cases (even error).
*
* @param[in] ctx libyang Context
* @param[in] type Type of the value being stored.
* @param[in] value Lexical representation of the value to be stored.
* It is never NULL, empty string is represented as "" with zero @p value_len.
* @param[in] value_len Length (number of bytes) of the given @p value.
* @param[in] options [Type plugin store options](@ref plugintypestoreopts).
* @param[in] format Input format of the value, see the description for details.
* @param[in] prefix_data Format-specific data for resolving any prefixes (see ly_resolve_prefix()).
* @param[in] hints Bitmap of [value hints](@ref lydvalhints) of all the allowed value types.
* @param[in] ctx_node Schema context node of @p value.
* @param[out] storage Storage for the value in the type's specific encoding. Except for _canonical, all the members
* should be filled by the plugin (if it fills them at all).
* @param[in,out] unres Global unres structure for newly implemented modules.
* @param[out] err Optionally provided error information in case of failure. If not provided to the caller, a generic
* error message is prepared instead. The error structure can be created by ::ly_err_new().
* @return LY_SUCCESS on success,
* @return LY_EINCOMPLETE in case the ::lyplg_type_validate_clb should be called to finish value validation in data,
* @return LY_ERR value on error.
*/
typedef LY_ERR (*lyplg_type_store_clb)(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 *prefix_data, uint32_t hints,
const struct lysc_node *ctx_node, struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/**
* @brief Callback to validate the stored value in data.
*
* This callback is optional for types that can only be validated in a data tree. It must be called and succeed
* in case the ::lyplg_type_store_clb callback returned ::LY_EINCOMPLETE for the value to be valid. However, this
* callback can be called even in other cases (such as separate/repeated validation).
*
* @param[in] ctx libyang Context
* @param[in] type Original type of the value (not necessarily the stored one) being validated.
* @param[in] ctx_node The value data context node for validation.
* @param[in] tree External data tree (e.g. when validating RPC/Notification) with possibly referenced data.
* @param[in,out] storage Storage of the value successfully filled by ::lyplg_type_store_clb. May be modified.
* @param[out] err Optionally provided error information in case of failure. If not provided to the caller, a generic
* error message is prepared instead. The error structure can be created by ::ly_err_new().
* @return LY_SUCCESS on success,
* @return LY_ERR value on error.
*/
typedef LY_ERR (*lyplg_type_validate_clb)(const struct ly_ctx *ctx, const struct lysc_type *type,
const struct lyd_node *ctx_node, const struct lyd_node *tree, struct lyd_value *storage, struct ly_err_item **err);
/**
* @brief Callback for comparing 2 values of the same type.
*
* In case the value types (::lyd_value.realtype) are different, ::LY_ENOT must always be returned.
* It can be assumed that the same context (dictionary) was used for storing both values.
*
* @param[in] val1 First value to compare.
* @param[in] val2 Second value to compare.
* @return LY_SUCCESS if values are same (according to the type's definition of being same).
* @return LY_ENOT if values differ.
*/
typedef LY_ERR (*lyplg_type_compare_clb)(const struct lyd_value *val1, const struct lyd_value *val2);
/**
* @brief Callback for getting the value of the data stored in @p value.
*
* Canonical value (@p format of ::LY_VALUE_CANON) must always be a zero-terminated const string stored in
* the dictionary. The ::lyd_value._canonical member should be used for storing (caching) it.
*
* @param[in] ctx libyang context for storing the canonical value.
* @param[in] value Value to print.
* @param[in] format Format in which the data are supposed to be printed. Formats ::LY_VALUE_SCHEMA and
* ::LY_VALUE_SCHEMA_RESOLVED are not supported and should not be implemented.
* @param[in] prefix_data Format-specific data for processing prefixes. In case of using one of the built-in's print
* callback (or ::lyplg_type_print_simple()), the argument is just simply passed in. If you need to handle prefixes
* in the value on your own, there is ::lyplg_type_get_prefix() function to help.
* @param[out] dynamic Flag if the returned value is dynamically allocated. In such a case the caller is responsible
* for freeing it. Will not be set and should be ignored for @p format ::LY_VALUE_CANON.
* @param[out] value_len Optional returned value length in bytes. For strings it EXCLUDES the terminating zero.
* @return Pointer to @p value in the specified @p format. According to the returned @p dynamic flag, caller
* can be responsible for freeing allocated memory.
* @return NULL in case of error.
*/
typedef const void *(*lyplg_type_print_clb)(const struct ly_ctx *ctx, const struct lyd_value *value,
LY_VALUE_FORMAT format, void *prefix_data, ly_bool *dynamic, size_t *value_len);
/**
* @brief Callback for getting the value hash key. The only requirement is that for 2 equal values this key
* MUST be equal. If possible, for 2 non-equal values this key should not be equal.
*
* It should always be possible to return the canonical value.
*
* @param[in] value Value to get the hash key of.
* @param[out] dynamic Flag if the returned hash key is dynamically allocated. In such a case the caller is responsible
* for freeing it.
* @param[out] key_len Returned hash key length in bytes.
* @return Hash key.
*/
typedef const void *(*lyplg_type_hash_clb)(const struct lyd_value *value, ly_bool *dynamic, size_t *key_len);
/**
* @brief Callback to duplicate data in the data structure.
*
* @param[in] ctx libyang context of the @p dup. Note that the context of @p original and @p dup might not be the same.
* @param[in] original Original data structure to be duplicated.
* @param[in,out] dup Prepared data structure to be filled with the duplicated data of @p original.
* @return LY_SUCCESS after successful duplication.
* @return LY_ERR value on error.
*/
typedef LY_ERR (*lyplg_type_dup_clb)(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup);
/**
* @brief Callback for freeing the user type values stored by ::lyplg_type_store_clb.
*
* Note that this callback is responsible also for freeing the canonized member in the @p value.
*
* @param[in] ctx libyang ctx to enable correct manipulation with values that are in the dictionary.
* @param[in,out] value Value structure to free the data stored there by the plugin's ::lyplg_type_store_clb callback
*/
typedef void (*lyplg_type_free_clb)(const struct ly_ctx *ctx, struct lyd_value *value);
/**
* @brief Hold type-specific functions for various operations with the data values.
*
* libyang includes set of plugins for all the built-in types. They are, by default, inherited to the derived types.
* However, if the user type plugin for the specific type is loaded, the plugin can provide it's own functions.
* The built-in types plugin callbacks are public, so even the user type plugins can use them to do part of their own
* functionality.
*/
struct lyplg_type {
const char *id; /**< Plugin identification (mainly for distinguish incompatible versions when
used by external tools) */
lyplg_type_store_clb store; /**< store and canonize the value in the type-specific way */
lyplg_type_validate_clb validate; /**< optional, validate the value in the type-specific way in data */
lyplg_type_compare_clb compare; /**< comparison callback to compare 2 values of the same type */
lyplg_type_print_clb print; /**< printer callback to get string representing the value */
lyplg_type_hash_clb hash; /**< hash callback to get the hash key of the value */
lyplg_type_dup_clb duplicate; /**< data duplication callback */
lyplg_type_free_clb free; /**< optional function to free the type-spceific way stored value */
};
struct lyplg_type_record {
/* plugin identification */
const char *module; /**< name of the module where the type is defined (top-level typedef) */
const char *revision; /**< optional module revision - if not specified, the plugin applies to any revision,
which is not an optimal approach due to a possible future revisions of the module.
Instead, there should be defined multiple items in the plugins list, each with the
different revision, but all with the same pointer to the plugin functions. The
only valid use case for the NULL revision is the case the module has no revision. */
const char *name; /**< name of the typedef */
/* runtime data */
struct lyplg_type plugin; /**< data to utilize plugin implementation */
};
/**
* @defgroup pluginsTypesSimple Plugins: Simple Types Callbacks
* @ingroup pluginsTypes
* @{
*
* Simple functions implementing @ref howtoPluginsTypes callbacks handling simply just the canonical string of the value
* (::lyd_value._canonical).
*/
/**
* @brief Generic simple comparison callback checking the canonical value.
* Implementation of the ::lyplg_type_compare_clb.
*/
LY_ERR lyplg_type_compare_simple(const struct lyd_value *val1, const struct lyd_value *val2);
/**
* @brief Generic simple printer callback of the canonized value.
* Implementation of the ::lyplg_type_print_clb.
*/
const void *lyplg_type_print_simple(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
void *prefix_data, ly_bool *dynamic, size_t *value_len);
/**
* @brief Generic simple hash callback of the canonized value.
* Implementation of the ::lyplg_type_hash_clb.
*/
const void *lyplg_type_hash_simple(const struct lyd_value *value, ly_bool *dynamic, size_t *key_len);
/**
* @brief Generic simple duplication callback.
* Implementation of the ::lyplg_type_dup_clb.
*/
LY_ERR lyplg_type_dup_simple(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup);
/**
* @brief Generic cleanup callback freeing only the canonized value in ::lyd_value._canonical.
* Simple implementation of the ::lyplg_type_free_clb.
*/
void lyplg_type_free_simple(const struct ly_ctx *ctx, struct lyd_value *value);
/** @} pluginsTypesSimple */
/**
* @defgroup pluginsTypesBinary Plugins: Binary built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement binary built-in type.
*/
/**
* @brief Validate, canonize and store value of the YANG built-in binary type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_binary(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/** @} pluginsTypesBinary */
/**
* @defgroup pluginsTypesBits Plugins: Bits built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement bits built-in type.
*/
/**
* @brief Validate, canonize and store value of the YANG built-in bits type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_bits(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/**
* @brief Duplication callback of the bits values.
* Implementation of the ::lyplg_type_dup_clb.
*/
LY_ERR lyplg_type_dup_bits(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup);
/**
* @brief Free value of the YANG built-in bits type.
* Implementation of the ::lyplg_type_free_clb.
*/
void lyplg_type_free_bits(const struct ly_ctx *ctx, struct lyd_value *value);
/** @} pluginsTypesBits */
/**
* @defgroup pluginsTypesBoolean Plugins: Boolean built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement boolean built-in type.
*/
/**
* @brief Validate and store value of the YANG built-in boolean type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_boolean(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/** @} pluginsTypesBoolean */
/**
* @defgroup pluginsTypesDecimal64 Plugins: Decimal64 built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement decimal64 built-in type.
*/
/**
* @brief Validate, canonize and store value of the YANG built-in decimal64 types.
* Implementation of the ::lyplg_type_store_clb.
*/
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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/** @} pluginsTypesDecimal64 */
/**
* @defgroup pluginsTypesEmpty Plugins: Empty built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement empty built-in type.
*/
/**
* @brief Validate and store value of the YANG built-in empty type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_empty(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/** @} pluginsTypesEmpty */
/**
* @defgroup pluginsTypesEnumeration Plugins: Enumeration built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement enumeration built-in type.
*/
/**
* @brief Validate, canonize and store value of the YANG built-in enumeration type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_enum(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/** @} pluginsTypesEnumeration */
/**
* @defgroup pluginsTypesIdentityref Plugins: Identityref built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement identityref built-in type.
*/
/**
* @brief Validate, canonize and store value of the YANG built-in identiytref type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_identityref(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/**
* @brief Comparison callback for built-in identityref type.
* Implementation of the ::lyplg_type_compare_clb.
*/
LY_ERR lyplg_type_compare_identityref(const struct lyd_value *val1, const struct lyd_value *val2);
/**
* @brief Printer callback printing identityref value.
* Implementation of the ::lyplg_type_print_clb.
*/
const void *lyplg_type_print_identityref(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
void *prefix_data, ly_bool *dynamic, size_t *value_len);
/** @} pluginsTypesIdentityref */
/**
* @defgroup pluginsTypesInstanceid Plugins: Instance-identifier built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement instance-identifier built-in type.
*/
/**
* @brief Validate and store value of the YANG built-in instance-identifier type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_instanceid(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/**
* @brief Comparison callback checking the instance-identifier value.
* Implementation of the ::lyplg_type_compare_clb.
*/
LY_ERR lyplg_type_compare_instanceid(const struct lyd_value *val1, const struct lyd_value *val2);
/**
* @brief Printer callback printing the instance-identifier value.
* Implementation of the ::lyplg_type_print_clb.
*/
const void *lyplg_type_print_instanceid(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
void *prefix_data, ly_bool *dynamic, size_t *value_len);
/**
* @brief Duplication callback of the instance-identifier values.
* Implementation of the ::lyplg_type_dup_clb.
*/
LY_ERR lyplg_type_dup_instanceid(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup);
/**
* @brief Validate value of the YANG built-in instance-identifier type.
* Implementation of the ::lyplg_type_validate_clb.
*/
LY_ERR lyplg_type_validate_instanceid(const struct ly_ctx *ctx, const struct lysc_type *type, const struct lyd_node *ctx_node,
const struct lyd_node *tree, struct lyd_value *storage, struct ly_err_item **err);
/**
* @brief Free value of the YANG built-in instance-identifier types.
* Implementation of the ::lyplg_type_free_clb.
*/
void lyplg_type_free_instanceid(const struct ly_ctx *ctx, struct lyd_value *value);
/** @} pluginsTypesInstanceid */
/**
* @defgroup pluginsTypesInteger Plugins: Integer built-in types callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement integer built-in types.
*/
/**
* @brief Validate, canonize and store value of the YANG built-in signed integer types.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_int(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/**
* @brief Validate and canonize value of the YANG built-in unsigned integer types.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_uint(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/** @} pluginsTypesInteger */
/**
* @defgroup pluginsTypesLeafref Plugins: Leafref built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement leafref built-in type.
*/
/**
* @brief Validate, canonize and store value of the YANG built-in leafref type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_leafref(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/**
* @brief Comparison callback checking the leafref value.
* Implementation of the ::lyplg_type_compare_clb.
*/
LY_ERR lyplg_type_compare_leafref(const struct lyd_value *val1, const struct lyd_value *val2);
/**
* @brief Printer callback printing the leafref value.
* Implementation of the ::lyplg_type_print_clb.
*/
const void *lyplg_type_print_leafref(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
void *prefix_data, ly_bool *dynamic, size_t *value_len);
/**
* @brief Hash key callback for a leafref value.
* Implementation of ::lyplg_type_hash_clb.
*/
const void *lyplg_type_hash_leafref(const struct lyd_value *value, ly_bool *dynamic, size_t *key_len);
/**
* @brief Duplication callback of the leafref values.
* Implementation of the ::lyplg_type_dup_clb.
*/
LY_ERR lyplg_type_dup_leafref(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup);
/**
* @brief Validate value of the YANG built-in leafref type.
* Implementation of the ::lyplg_type_validate_clb.
*/
LY_ERR lyplg_type_validate_leafref(const struct ly_ctx *ctx, const struct lysc_type *type, const struct lyd_node *ctx_node,
const struct lyd_node *tree, struct lyd_value *storage, struct ly_err_item **err);
/**
* @brief Free value of the YANG built-in leafref types.
* Implementation of the ::lyplg_type_free_clb.
*/
void lyplg_type_free_leafref(const struct ly_ctx *ctx, struct lyd_value *value);
/** @} pluginsTypesLeafref */
/**
* @defgroup pluginsTypesString Plugins: String built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement string built-in type.
*/
/**
* @brief Validate and store value of the YANG built-in string type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_string(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/** @} pluginsTypesString */
/**
* @defgroup pluginsTypesUnion Plugins: Union built-in type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement union built-in type.
*/
/**
* @brief Validate, canonize and store value of the YANG built-in union type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_union(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/**
* @brief Comparison callback checking the union value.
* Implementation of the ::lyplg_type_compare_clb.
*/
LY_ERR lyplg_type_compare_union(const struct lyd_value *val1, const struct lyd_value *val2);
/**
* @brief Printer callback printing the union value.
* Implementation of the ::lyplg_type_print_clb.
*/
const void *lyplg_type_print_union(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
void *prefix_data, ly_bool *dynamic, size_t *value_len);
/**
* @brief Hash key callback for a union value.
* Implementation of ::lyplg_type_hash_clb.
*/
const void *lyplg_type_hash_union(const struct lyd_value *value, ly_bool *dynamic, size_t *key_len);
/**
* @brief Duplication callback of the union values.
* Implementation of the ::lyplg_type_dup_clb.
*/
LY_ERR lyplg_type_dup_union(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup);
/**
* @brief Validate value of the YANG built-in union type.
* Implementation of the ::lyplg_type_validate_clb.
*/
LY_ERR lyplg_type_validate_union(const struct ly_ctx *ctx, const struct lysc_type *type, const struct lyd_node *ctx_node,
const struct lyd_node *tree, struct lyd_value *storage, struct ly_err_item **err);
/**
* @brief Free value of the YANG built-in union types.
* Implementation of the ::lyplg_type_free_clb.
*/
void lyplg_type_free_union(const struct ly_ctx *ctx, struct lyd_value *value);
/** @} pluginsTypesUnion */
/**
* @defgroup pluginsTypesXpath10 Plugins: xpath1.0 `ietf-yang-types` type callbacks
* @ingroup pluginsTypes
* @{
*
* Callbacks used (besides the [simple callbacks](@ref pluginsTypesSimple)) to implement xpath1.0 derived type.
*/
/**
* @brief Validate, canonize and store value of the ietf-yang-types xpath1.0 type.
* Implementation of the ::lyplg_type_store_clb.
*/
LY_ERR lyplg_type_store_xpath10(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 *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err);
/**
* @brief Comparison callback checking the union value.
* Implementation of the ::lyplg_type_compare_clb.
*/
LY_ERR lyplg_type_compare_union(const struct lyd_value *val1, const struct lyd_value *val2);
/**
* @brief Printer callback printing the xpath1.0 value.
* Implementation of the ::lyplg_type_print_clb.
*/
const void *lyplg_type_print_xpath10(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
void *prefix_data, ly_bool *dynamic, size_t *value_len);
/**
* @brief Duplication callback of the xpath1.0 values.
* Implementation of the ::lyplg_type_dup_clb.
*/
LY_ERR lyplg_type_dup_xpath10(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup);
/**
* @brief Free value of the derived xpath1.0 types.
* Implementation of the ::lyplg_type_free_clb.
*/
void lyplg_type_free_xpath10(const struct ly_ctx *ctx, struct lyd_value *value);
/** @} pluginsTypesXpath10 */
/**
* @brief Unsigned integer value parser and validator.
*
* @param[in] datatype Type of the integer for logging.
* @param[in] base Base of the integer's lexical representation. In case of built-in types, data must be represented in decimal format (base 10),
* but default values in schemas can be represented also as hexadecimal or octal values (base 0).
* @param[in] min Lower bound of the type.
* @param[in] max Upper bound of the type.
* @param[in] value Value string to parse.
* @param[in] value_len Length of the @p value (mandatory parameter).
* @param[out] ret Parsed integer value (optional).
* @param[out] err Error information in case of failure. The error structure can be freed by ::ly_err_free().
* @return LY_ERR value according to the result of the parsing and validation.
*/
LY_ERR lyplg_type_parse_int(const char *datatype, int base, int64_t min, int64_t max, const char *value, size_t value_len,
int64_t *ret, struct ly_err_item **err);
/**
* @brief Unsigned integer value parser and validator.
*
* @param[in] datatype Type of the unsigned integer for logging.
* @param[in] base Base of the integer's lexical representation. In case of built-in types, data must be represented in decimal format (base 10),
* but default values in schemas can be represented also as hexadecimal or octal values (base 0).
* @param[in] max Upper bound of the type.
* @param[in] value Value string to parse.
* @param[in] value_len Length of the @p value (mandatory parameter).
* @param[out] ret Parsed unsigned integer value (optional).
* @param[out] err Error information in case of failure. The error structure can be freed by ::ly_err_free().
* @return LY_ERR value according to the result of the parsing and validation.
*/
LY_ERR lyplg_type_parse_uint(const char *datatype, int base, uint64_t max, const char *value, size_t value_len,
uint64_t *ret, struct ly_err_item **err);
/**
* @brief Convert a string with a decimal64 value into libyang representation:
* ret = value * 10^fraction-digits
*
* @param[in] fraction_digits Fraction-digits of the decimal64 type.
* @param[in] value Value string to parse.
* @param[in] value_len Length of the @p value (mandatory parameter).
* @param[out] ret Parsed decimal64 value representing original value * 10^fraction-digits (optional).
* @param[out] err Error information in case of failure. The error structure can be freed by ::ly_err_free().
* @return LY_ERR value according to the result of the parsing and validation.
*/
LY_ERR lyplg_type_parse_dec64(uint8_t fraction_digits, const char *value, size_t value_len, int64_t *ret, struct ly_err_item **err);
/**
* @brief Decide if the @p derived identity is derived from (based on) the @p base identity.
*