Inlined Radix Tree Variable Size Value Associative Array (libx1f4l2)

4.2.3.1 Inlined Radix Tree Variable Size Value Associative Array

The associative array is constructed over a path compressed trie. The trie is a character (byte) one, i.e. node selection uses 8 bits. Nodes having a common parent are stored as a sorted array - node selection is binary search derived. The trie is prefix compressed - common prefixes are stripped from path internal vertexes. When short enough, the internal vertexes are stored in place of the pointers that would otherwise point to them.

The trie cannot store binary keys (strings containing null characters).

The associative array is similar to one of the pointer value ones, save that the keys are stored in full and the value is of variable size.

See Inlined Radix Tree Associative Array.

General library:

See String Key Variable Size Value Array Library.

See String Key Variable Size Value Array Search Library.

The call data structure size retriever:
```
int x1f4_call_sfnote(unsigned *);
```
The case data structure state retriever:
```
int x1f4_case_sfnote(void *);
```

The cast plain data deletion routine:

int x1f4_cast_sfnote(void *, const char *);

The drop data deletion routine:

int x1f4_drop_sfnote
    (void *, const char *, void *, int (*)(void *, void *));

The ever record retriever:
```
int x1f4_ever_sfnote(void *, void **);
```

The fast associative array constructor routine:

int x1f4_fast_sfnote(void *, unsigned, struct x1f4_sfnote_type *);

The fgxq first greater search routine:

int x1f4_fgxq_sfnote
    (void *, const char *, void **, const char **, unsigned *);

The find plain search routine:

int x1f4_find_sfnote(void *, const char *, void **);

The fini associative array regular destructor routine:
```
int x1f4_fini_sfnote(void **);
```
The flat associative array destructor routine:
```
int x1f4_flat_sfnote(void *);
```
The flow data structure integrity check routine:
```
int x1f4_flow_sfnote(void *);
```

The fold record retriever:

int x1f4_fold_sfnote(void *, void **, const char **, unsigned *);

The fxxq first greater or matching search routine:

int x1f4_fxxq_sfnote
    (void *, const char *, void **, const char **, unsigned *);

The high data purge routine:
```
int x1f4_high_sfnote(void *);
```

The hike record retriever:

int x1f4_hike_sfnote(void *, void **, const char **, unsigned *);

The init associative array regular constructor routine:

int x1f4_init_sfnote(void **, unsigned, struct x1f4_sfnote_type *);

The join associative array consolidation routine:
```
int x1f4_join_sfnote(void *, void *);
```
The lead record retriever:
```
int x1f4_lead_sfnote(void *, void **);
```

The lime data traversal routine:

int x1f4_lime_sfnote(void *, void *, int (*)(void *, void *));

The line data copy routine:

int x1f4_line_sfnote
    (void *, void *, int (*)(void *, unsigned *, const void *),
     int (*)(void *, void *, const void *), int (*)(void *, void *),
     void *);

The llxq last less search routine:

int x1f4_llxq_sfnote
    (void *, const char *, void **, const char **, unsigned *);

The lxxq last less or matching search routine:

int x1f4_lxxq_sfnote
    (void *, const char *, void **, const char **, unsigned *);

The mind data deletion routine:
```
int x1f4_mind_sfnote(void *);
```

The note data traversal routine:

int x1f4_note_sfnote
    (void *, void *, int (*)(void *, const char *, unsigned));

The pass plain data deletion routine:

int x1f4_pass_sfnote(void *, const char *);

The post plain data insertion routine:

int x1f4_post_sfnote(void *, const char *, unsigned, void **);

The shut plain data deletion routine:

int x1f4_shut_sfnote
    (void *, const char *, void *, int (*)(void *, void *));

The skew memory allocator replacer routine:
```
int x1f4_skew_sfnote(void *, void *);
```
The slip data deletion routine:
```
int x1f4_slip_sfnote(void *);
```

The span data traversal routine:

int x1f4_span_sfnote
    (void *, void *, int (*)(void *, void *, const char *, unsigned));

The swap data swap routine:
```
int x1f4_swap_sfnote(void *, void *);
```

The tear associative array partition routine:

int x1f4_tear_sfnote(void *, const char *, int, void *);

The text plain copy routine:

int x1f4_text_sfnote
    (void **, void *, int (*)(void *, unsigned *, const void *),
     int (*)(void *, void *, const void *), int (*)(void *, void *),
     void *);