@based/db 0.1.3 → 0.1.5

package/dist/lib/linux_x86_64/include/selva/fast_linear_search.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2024 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include "selva/types.h"
+
+struct SelvaNode;
+struct SelvaNodeSmallReference;
+struct SelvaNodeLargeReference;
+
+SELVA_EXPORT
+ssize_t fast_linear_search_uint32(const uint32_t arr[], size_t len, uint32_t x);
+
+SELVA_EXPORT
+ssize_t fast_linear_search_node_id(const node_id_t arr[], size_t len, node_id_t x);
+
+SELVA_EXPORT
+ssize_t fast_linear_search_node(const struct SelvaNode *arr[], size_t len, const struct SelvaNode *x);
+
+SELVA_EXPORT
+ssize_t fast_linear_search_references_small(const struct SelvaNodeSmallReference *arr, size_t len, node_id_t x);
+
+SELVA_EXPORT
+ssize_t fast_linear_search_references_large(const struct SelvaNodeLargeReference *arr, size_t len, node_id_t x);

package/dist/lib/linux_x86_64/include/selva/fast_memcmp.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include <stddef.h>
+#include "selva/_export.h"
+
+/**
+ * Fast buffer equals comparison.
+ * @param a is an array of length len.
+ * @param b is an array of length len.
+ * @param len length of a and b in bytes, must be greater than 0.
+ * @returns true if a and b contains the same byte sequence; Otherwise false.
+ */
+SELVA_EXPORT
+bool fast_memcmp(const void *restrict a, const void *restrict b, size_t len);

package/dist/lib/linux_x86_64/include/selva/fast_memmem.h

@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2024-2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include <stddef.h>
+#include "selva/_export.h"
+
+SELVA_EXPORT
+void *fast_memmem(const void *h0, size_t k, const void *n0, size_t l);

package/dist/lib/linux_x86_64/include/selva/fast_parsei.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2022-2023, 2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+/**
+ * Like atoi but faster and more unsafe.
+ * This is way faster than strtoll() in glibc.
+ */
+static inline int fast_atou(const char *str)
+{
+    int n = 0;
+
+    while (*str >= '0' && *str <= '9') {
+        n = n * 10 + (int)(*str++) - '0';
+    }
+
+    return n;
+}
+
+/**
+ * Like strtol but faster and more unsafe.
+ * This is way faster than strtoll() in glibc.
+ */
+static inline int fast_strtou(const char *str, const char **end)
+{
+    int n = 0;
+
+    while (*str >= '0' && *str <= '9') {
+        n = n * 10 + (int)(*str++) - '0';
+    }
+
+    *end = str;
+    return n;
+}

package/dist/lib/linux_x86_64/include/selva/fields.h

@@ -0,0 +1,379 @@
+/*
+ * Copyright (c) 2024-2025 SAULX
+ * SPDX-License-Identifier: MIT
+ */
+#pragma once
+
+#include <stdint.h>
+#include <sys/types.h>
+#include "selva/_export.h"
+#ifdef __zig
+struct selva_string;
+#else
+#include "selva/selva_string.h"
+#endif
+#include "selva/types.h"
+#include "selva_lang_code.h"
+
+struct XXH3_state_s; /* RFE Not good? */
+
+#ifndef __zig
+struct SelvaTextField {
+    struct selva_string *tl __pcounted_by(len);
+    uint8_t len;
+} __packed;
+#endif
+
+struct SelvaNodeSmallReference {
+    node_id_t dst;
+};
+
+struct SelvaNodeLargeReference {
+    node_id_t dst;
+    node_id_t meta;
+};
+
+enum SelvaNodeReferenceType {
+    SELVA_NODE_REFERENCE_NULL = 0,
+    SELVA_NODE_REFERENCE_SMALL = 1,
+    SELVA_NODE_REFERENCE_LARGE = 2,
+} __packed;
+
+struct SelvaNodeReferenceAny {
+    enum SelvaNodeReferenceType type;
+    union {
+        void *any;
+        struct SelvaNodeSmallReference *small;
+        struct SelvaNodeLargeReference *large;
+    }
+#ifdef __zig
+      p
+#endif
+    ;
+};
+
+static_assert(offsetof(struct SelvaNodeLargeReference, dst) == offsetof(struct SelvaNodeSmallReference, dst));
+
+struct SelvaNodeReferences {
+    uint32_t nr_refs;
+    uint16_t offset;
+    enum SelvaNodeReferenceType size;
+
+    union {
+        void *any;
+        struct SelvaNodeLargeReference *large __pcounted_by(nr_refs);
+        struct SelvaNodeSmallReference *small __pcounted_by(nr_refs);
+    };
+    node_id_t *index __pcounted_by(nr_refs); /*!< Sorted index of all nodes in `.refs`. */
+};
+static_assert(offsetof(struct SelvaNodeReferences, any) == offsetof(struct SelvaNodeReferences, small));
+static_assert(offsetof(struct SelvaNodeReferences, any) == offsetof(struct SelvaNodeReferences, large));
+static_assert(offsetof(struct SelvaNodeReferences, small) == offsetof(struct SelvaNodeReferences, large));
+
+struct SelvaNodeWeakReference {
+    /* The type can be found from the schema. */
+#if 0
+    node_type_t dst_type;
+#endif
+    node_id_t dst_id;
+};
+
+struct SelvaNodeWeakReferences {
+    uint32_t nr_refs;
+    uint32_t offset;
+    struct SelvaNodeWeakReference *refs __pcounted_by(nr_refs);
+};
+
+struct SelvaFieldsPointer {
+    uint8_t *ptr;
+    size_t off;
+    size_t len;
+};
+
+/**
+ * Precalculated empty strings for text translations.
+ * The size of the string is 8 for better alignment but they are only
+ * filled upto 6 bytes.
+ */
+SELVA_EXPORT
+extern const uint8_t selva_fields_text_tl_empty[_selva_lang_last][8];
+
+#define SELVA_FIELDS_TEXT_TL_EMPTY_LEN 6
+
+#if __has_c_attribute(unsequenced)
+[[unsequenced]]
+#else
+__purefn
+#endif
+size_t selva_fields_get_data_size(const struct SelvaFieldSchema *fs);
+
+SELVA_EXPORT
+#if __has_c_attribute(reproducible)
+[[reproducible]]
+#endif
+void *selva_fields_nfo2p(struct SelvaFields *fields, const struct SelvaFieldInfo *nfo);
+
+SELVA_EXPORT
+struct SelvaFields *selva_fields_node2fields(struct SelvaNode *node);
+
+SELVA_EXPORT
+struct SelvaNode *selva_fields_ensure_ref_meta(
+        struct SelvaDb *db,
+        struct SelvaNode *node,
+        const struct EdgeFieldConstraint *efc,
+        struct SelvaNodeLargeReference *ref,
+        node_id_t meta_id,
+        selva_dirty_node_cb_t dirty_cb, void *dirty_ctx);
+
+SELVA_EXPORT
+int selva_fields_get_mutable_string(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        size_t len,
+        struct selva_string **s)
+    __attribute__((access(write_only, 4)));
+
+SELVA_EXPORT
+struct SelvaFieldInfo *selva_fields_ensure(struct SelvaFields *fields, const struct SelvaFieldSchema *fs);
+
+/*
+ * TODO Document diff to get_mutable_string
+ */
+SELVA_EXPORT
+struct selva_string *selva_fields_ensure_string(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        size_t initial_len);
+
+/**
+ * Set reference to fields.
+ */
+SELVA_EXPORT
+int selva_fields_reference_set(
+        struct SelvaDb *db,
+        struct SelvaNode * restrict src,
+        const struct SelvaFieldSchema *fs_src,
+        struct SelvaNode * restrict dst,
+        struct SelvaNodeReferenceAny *ref_out,
+        selva_dirty_node_cb_t dirty_cb,
+        void *dirty_ctx);
+    // __attribute__((access(write_only, 5), access(write_only, 6)));
+
+/**
+ * @param index 0 = first; -1 = last.
+ * @param reorder move the existing ref to `index` instead of returning EEXIST.
+ */
+SELVA_EXPORT
+int selva_fields_references_insert(
+        struct SelvaDb *db,
+        struct SelvaNode * restrict node,
+        const struct SelvaFieldSchema *fs,
+        ssize_t index,
+        bool reorder,
+        struct SelvaTypeEntry *te_dst,
+        struct SelvaNode * restrict dst,
+        struct SelvaNodeReferenceAny *ref_out,
+        selva_dirty_node_cb_t dirty_cb, void *dirty_ctx, bool ignore_src_dependent)
+    __attribute__((access(write_only, 8)));
+
+/**
+ * Prealloc a references field buffer.
+ * @returns nr_refs.
+ */
+SELVA_EXPORT
+size_t selva_fields_prealloc_refs(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs, size_t nr_refs_min);
+
+SELVA_EXPORT
+int selva_fields_references_insert_tail_wupsert(
+        struct SelvaDb *db,
+        struct SelvaNode * restrict node,
+        const struct SelvaFieldSchema *fs,
+        struct SelvaTypeEntry *te_dst,
+        const node_id_t ids[],
+        size_t nr_ids,
+        selva_dirty_node_cb_t dirty_cb, void *dirty_ctx)
+    __attribute__((access(read_only, 5, 6)));
+
+/**
+ * Move reference from old to new index in a references field array.
+ * If index_new > index_old then the ref will be after the reference that was in index_new before the operation;
+ * If index_new < index_ld then the ref  will be before the reference that was in the index_new before the operation.
+ * index_new and index_old can be negative, which will start counting the references array from the last position.
+ * It's not possible to create a gap of null references using this function.
+ */
+SELVA_EXPORT
+int selva_fields_references_move(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        ssize_t index_old,
+        ssize_t index_new);
+
+/**
+ * Swap two references in a references field array.
+ */
+SELVA_EXPORT
+int selva_fields_references_swap(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        size_t index_a,
+        size_t index_b);
+
+/**
+ * Set string field.
+ *
+ * str format:
+ *  0      1      2          len
+ * +------+------+--------+-----+
+ * | LANG | COMP |  DATA  | CRC |
+ * +------+------+--------+-----+
+ */
+SELVA_EXPORT
+int selva_fields_set_string(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        const char *str,
+        size_t len);
+
+/**
+ * Set text field translation.
+ *
+ * str format:
+ *  0      1      2          len
+ * +------+------+--------+-----+
+ * | LANG | COMP |  DATA  | CRC |
+ * +------+------+--------+-----+
+ */
+SELVA_EXPORT
+int selva_fields_set_text(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        const char *str,
+        size_t len);
+
+int selva_fields_get_mutable_text(
+        struct SelvaNode *node,
+        const struct SelvaFieldSchema *fs,
+        enum selva_lang_code lang,
+        size_t len,
+        struct selva_string **out);
+
+/**
+ * Get text field translation.
+ *
+ * str format:
+ *  0      1      2          len
+ * +------+------+--------+-----+
+ * | LANG | COMP |  DATA  | CRC |
+ * +------+------+--------+-----+
+ */
+SELVA_EXPORT
+int selva_fields_get_text(
+        struct SelvaNode * restrict node,
+        const struct SelvaFieldSchema *fs,
+        enum selva_lang_code lang,
+        const char **str,
+        size_t *len);
+
+SELVA_EXPORT
+int selva_fields_set_micro_buffer(struct SelvaFields *fields, const struct SelvaFieldSchema *fs, const void *value, size_t len);
+
+SELVA_EXPORT
+int selva_fields_set_micro_buffer2(struct SelvaNode *node, const struct SelvaFieldSchema *fs, const void *value, size_t len);
+
+SELVA_EXPORT
+int selva_fields_set_weak_reference(struct SelvaNode *node, const struct SelvaFieldSchema *fs, node_id_t dst);
+
+SELVA_EXPORT
+int selva_fields_set_weak_reference2(struct SelvaFields *fields, const struct SelvaFieldSchema *fs, node_id_t dst);
+
+SELVA_EXPORT
+int selva_fields_set_weak_references2(struct SelvaFields *fields, const struct SelvaFieldSchema *fs, node_id_t dst[], size_t nr_dsts);
+
+SELVA_EXPORT
+int selva_fields_set_weak_references(struct SelvaNode *node, const struct SelvaFieldSchema *fs, node_id_t dst[], size_t nr_dsts);
+
+SELVA_EXPORT
+struct SelvaNodeLargeReference *selva_fields_get_reference(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs)
+    __attribute__((nonnull));
+
+SELVA_EXPORT
+struct SelvaNodeReferences *selva_fields_get_references(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs)
+    __attribute__((nonnull));
+
+SELVA_EXPORT
+struct SelvaNodeWeakReference selva_fields_get_weak_reference(struct SelvaFields *fields, field_t field)
+    __attribute__((nonnull));
+
+SELVA_EXPORT
+struct SelvaNodeWeakReferences selva_fields_get_weak_references(struct SelvaFields *fields, field_t field)
+    __attribute__((nonnull));
+
+SELVA_EXPORT
+struct SelvaNode *selva_fields_resolve_weak_reference(
+        const struct SelvaDb *db,
+        const struct SelvaFieldSchema *fs,
+        const struct SelvaNodeWeakReference *weak_ref)
+    __attribute__((nonnull));
+
+SELVA_EXPORT
+struct selva_string *selva_fields_get_selva_string2(struct SelvaFields *fields, const struct SelvaFieldSchema *fs)
+    __attribute__((nonnull));
+
+SELVA_EXPORT
+struct selva_string *selva_fields_get_selva_string(struct SelvaNode *node, const struct SelvaFieldSchema *fs)
+    __attribute__((nonnull));
+
+SELVA_EXPORT
+struct SelvaFieldInfo *selva_field_get_nfo(struct SelvaFields *fields, const struct SelvaFieldSchema *fs);
+
+SELVA_EXPORT
+struct SelvaFieldsPointer selva_fields_get_raw2(struct SelvaFields *fields, const struct SelvaFieldSchema *fs)
+    __attribute__((nonnull));
+
+SELVA_EXPORT
+struct SelvaFieldsPointer selva_fields_get_raw(struct SelvaNode *node, const struct SelvaFieldSchema *fs)
+    __attribute__((nonnull));
+
+/**
+ * Delete field.
+ * @param dirty_cb will be called with the deleted node_id in case of a reference(s) field.
+ */
+SELVA_EXPORT
+int selva_fields_del(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx)
+    __attribute__((nonnull(1, 2, 3)));
+
+/**
+ * Delete an edge from a references field.
+ */
+SELVA_EXPORT
+int selva_fields_del_ref(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs, node_id_t dst_node_id, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx);
+
+/**
+ * Clear a references field but don't free it.
+ */
+SELVA_EXPORT
+void selva_fields_clear_references(struct SelvaDb *db, struct SelvaNode *node, const struct SelvaFieldSchema *fs, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx)
+    __attribute__((nonnull(1, 2, 3)));
+
+/**
+ * Init the fields struct of a node or edge.
+ */
+SELVA_EXPORT
+void selva_fields_init(const struct SelvaFieldsSchema *schema, struct SelvaFields *fields)
+    __attribute__((nonnull));
+
+void selva_fields_init_node(struct SelvaTypeEntry *te, struct SelvaNode *node)
+    __attribute__((nonnull));
+
+/**
+ * Destroy all fields of a node.
+ */
+SELVA_EXPORT
+void selva_fields_destroy(struct SelvaDb *db, struct SelvaNode *node, selva_dirty_node_cb_t dirty_cb, void *dirty_ctx)
+    __attribute__((nonnull(1, 2)));
+
+SELVA_EXPORT
+void selva_fields_hash_update(struct XXH3_state_s *hash_state, struct SelvaDb *db, const struct SelvaFieldsSchema *schema, const struct SelvaFields *fields);
+
+SELVA_EXPORT
+selva_hash128_t selva_fields_hash(struct SelvaDb *db, const struct SelvaFieldsSchema *schema, const struct SelvaFields *fields);

package/dist/lib/linux_x86_64/include/selva/gmtime.h

@@ -0,0 +1,137 @@
+/**
+ *******************************************************************************
+ * @file    gmtime.h
+ * @author  Olli Vanhoja
+ * @brief   Calendar calculations.
+ * @section LICENSE
+ * Copyright (c) 2025 Saulx
+ * SPDX-License-Identifier: MIT
+ *******************************************************************************
+ */
+
+#pragma once
+#include <stdint.h>
+#include "selva/_export.h"
+
+#define SELVA_TM_SUNDAY       0
+#define SELVA_TM_MONDAY       1
+#define SELVA_TM_TUESDAY      2
+#define SELVA_TM_WEDNESDAY    3
+#define SELVA_TM_THURSDAY     4
+#define SELVA_TM_FRIDAY       5
+#define SELVA_TM_SATURDAY     6
+
+#define SELVA_TM_JANUARY      0
+#define SELVA_TM_FEBRUARY     1
+#define SELVA_TM_MARCH        2
+#define SELVA_TM_APRIL        3
+#define SELVA_TM_MAY          4
+#define SELVA_TM_JUNE         5
+#define SELVA_TM_JULY         6
+#define SELVA_TM_AUGUST       7
+#define SELVA_TM_SEPTEMBER    8
+#define SELVA_TM_OCTOBER      9
+#define SELVA_TM_NOVEMBER     10
+#define SELVA_TM_DECEMBER     11
+
+#define SELVA_EPOCH_YEAR      1970
+
+/**
+ * Gregorian Calendar.
+ */
+struct selva_tm {
+    int32_t tm_sec;     /*!< Seconds [0,60]. */
+    int32_t tm_min;     /*!< Minutes [0,59]. */
+    int32_t tm_hour;    /*!< Hour [0,23]. */
+    int32_t tm_mday;    /*!< Day of month [1,31]. */
+    int32_t tm_mon;     /*!< Month of year [0,11]. */
+    int32_t tm_year;    /*!< Year. */
+    int32_t tm_wday;    /*!< Day of week [0,6] (Sunday =0). */
+    int32_t tm_yday;    /*!< Day of year [0,365]. */
+    bool tm_yleap;      /*!< Is leap year. */
+};
+
+/**
+ * ISO-8601 Week Date.
+ */
+struct selva_iso_week {
+    int32_t iso_year; /*!< ISO year. */
+    int32_t iso_week; /*!< ISO week [1,54]. */
+};
+
+static inline int32_t selva_gmtime_wday2iso_wday(int32_t wday)
+{
+    /* Same as (tm.tm_wday + 6) % 7 + 1 but fewer instructions. */
+    return wday ? wday : 7;
+}
+
+/**
+ * Calculate struct selva_tm from ts and tmz in Gregorian calendar.
+ * @param ts in ms.
+ * @param tmz in minutes.
+ */
+SELVA_EXPORT
+void selva_gmtime(struct selva_tm *result, int64_t ts, int64_t tmz);
+
+/**
+ * Calculate Gregorian year from ts and tmz.
+ * @param ts in ms.
+ * @param tmz in minutes.
+ * @returns Gregorian year.
+ */
+SELVA_EXPORT
+int32_t selva_gmtime_year(int64_t ts, int64_t tmz);
+
+/**
+ * Calculate Gregorian month from ts and tmz.
+ * @param ts in ms.
+ * @param tmz in minutes.
+ * @returns Gregorian month of year [0,11].
+ */
+SELVA_EXPORT
+int32_t selva_gmtime_mon(int64_t ts, int64_t tmz);
+
+/**
+ * Calculate Gregorian day of year from ts and tmz.
+ * @param ts in ms.
+ * @param tmz in minutes.
+ * @returns Gregorian day of year [0,365].
+ */
+SELVA_EXPORT
+int32_t selva_gmtime_yday(int64_t ts, int64_t tmz);
+
+/**
+ * Calculate Gregorian day of week from ts and tmz.
+ * @param ts in ms.
+ * @param tmz in minutes.
+ * @returns Gregorian day of week [0,6] (Sunday =0).
+ */
+SELVA_EXPORT
+int32_t selva_gmtime_wday(int64_t ts, int64_t tmz);
+
+/**
+ * Calculate Gregorian day of month from ts and tmz.
+ * @param ts in ms.
+ * @param tmz in minutes.
+ * @returns Gregorian day of month [1,31].
+ */
+SELVA_EXPORT
+int32_t selva_gmtime_mday(int64_t ts, int64_t tmz);
+
+/**
+ * Calculate hour from ts and tmz.
+ * @param ts in ms.
+ * @param tmz in minutes.
+ * @returns Hour [0, 23].
+ */
+SELVA_EXPORT
+int32_t selva_gmtime_hour(int64_t ts, int64_t tmz);
+
+/**
+ * Calculate the ISO-8601 week date from ts and tmz.
+ * @param ts in ms.
+ * @param tmz in minutes.
+ * @returns wyear.
+ */
+SELVA_EXPORT
+struct selva_iso_week *selva_gmtime_iso_wyear(struct selva_iso_week *wyear, int64_t ts, int64_t tmz);