mongory 0.7.3-aarch64-linux-musl

data/ext/mongory_ext/mongory-core/include/mongory-core/foundations/memory_pool.h

@@ -0,0 +1,95 @@
+#ifndef MONGORY_MEMORY_POOL
+#define MONGORY_MEMORY_POOL
+
+/**
+ * @file memory_pool.h
+ * @brief Defines the mongory_memory_pool structure and its associated
+ * operations.
+ *
+ * A memory pool is used for efficient memory management within the Mongory
+ * library. It allows for allocating blocks of memory that can be freed
+ * all at once when the pool itself is destroyed. This can reduce the overhead
+ * of individual allocations and deallocations and help prevent memory leaks.
+ */
+
+#include "mongory-core/foundations/error.h"
+#include <stdbool.h>
+#include <stdlib.h> // For size_t
+
+// Forward declaration of the memory pool structure.
+typedef struct mongory_memory_pool mongory_memory_pool;
+
+#define MG_ALLOC(p, n) (p->alloc(p, n))
+#define MG_ALLOC_PTR(p, t) ((t*)MG_ALLOC(p, sizeof(t)))
+#define MG_ALLOC_OBJ(p, t) ((t)MG_ALLOC(p, sizeof(t)))
+#define MG_ALLOC_ARY(p, t, n) ((t*)MG_ALLOC(p, sizeof(t) * (n)))
+/**
+ * @struct mongory_memory_pool
+ * @brief Represents a memory pool for managing memory allocations.
+ *
+ * The pool uses a context (`ctx`) to store its internal state, which typically
+ * includes a list of allocated memory chunks.
+ * It provides function pointers for allocation, tracing (optional), and freeing
+ * the entire pool. An error field can store information about the last error
+ * encountered during pool operations.
+ */
+struct mongory_memory_pool {
+  /**
+   * @brief Allocates a block of memory from the pool.
+   * @param ctx A pointer to the pool's internal context.
+   * @param size The number of bytes to allocate.
+   * @return void* A pointer to the allocated memory block, or NULL on failure.
+   * Memory allocated this way is typically aligned.
+   */
+  void *(*alloc)(mongory_memory_pool *pool, size_t size);
+
+  /**
+   * @brief Traces an externally allocated memory block, associating it with the
+   * pool.
+   *
+   * This is useful if memory is allocated outside the pool's `alloc` function
+   * (e.g., by an external library) but its lifecycle should be tied to the
+   * pool. When the pool is freed, traced memory blocks might also be freed
+   * depending on the pool's implementation.
+   *
+   * @param ctx A pointer to the pool's internal context.
+   * @param ptr A pointer to the memory block to trace.
+   * @param size The size of the memory block.
+   */
+  void (*trace)(mongory_memory_pool *pool, void *ptr, size_t size);
+
+  /**
+   * @brief Resets the memory pool to its initial state.
+   * @param ctx A pointer to the pool's internal context.
+   */
+  void (*reset)(mongory_memory_pool *pool);
+
+  /**
+   * @brief Frees the entire memory pool, including all memory blocks allocated
+   * from it and any traced memory blocks (depending on implementation).
+   * @param self A pointer to the mongory_memory_pool instance to be freed.
+   */
+  void (*free)(mongory_memory_pool *self);
+
+  void *ctx;            /**< Pointer to the internal context/state of the memory
+                           pool. This is managed by the pool implementation. */
+  mongory_error *error; /**< Pointer to a mongory_error structure. If an
+                           operation fails (e.g., allocation), this may be set
+                           to describe the error. The memory for this error
+                           struct itself is typically allocated from the pool or
+                           is a static error object. */
+};
+
+/**
+ * @brief Creates a new mongory_memory_pool instance.
+ *
+ * Initializes the pool structure and its internal context, preparing it for
+ * allocations.
+ *
+ * @return mongory_memory_pool* A pointer to the newly created memory pool, or
+ * NULL if creation fails (e.g., initial memory allocation for the pool's
+ * context failed).
+ */
+mongory_memory_pool *mongory_memory_pool_new();
+
+#endif /* MONGORY_MEMORY_POOL */

data/ext/mongory_ext/mongory-core/include/mongory-core/foundations/table.h

@@ -0,0 +1,127 @@
+#ifndef MONGORY_TABLE_H
+#define MONGORY_TABLE_H
+
+/**
+ * @file table.h
+ * @brief Defines the mongory_table structure (a hash table) and its
+ * associated operations.
+ *
+ * mongory_table implements a hash table mapping string keys to mongory_value
+ * pointers. It uses a mongory_memory_pool for its allocations and handles
+ * operations like get, set, delete, and iteration over key-value pairs.
+ * The table automatically resizes (rehashes) when its load factor is exceeded.
+ */
+
+#include "mongory-core/foundations/array.h" // Used internally by the table
+#include "mongory-core/foundations/memory_pool.h"
+#include "mongory-core/foundations/value.h"
+#include <stdbool.h>
+#include <stddef.h> // For size_t
+
+// Forward declaration of the mongory_table structure.
+struct mongory_table;
+/**
+ * @brief Alias for `struct mongory_table`.
+ */
+typedef struct mongory_table mongory_table;
+
+/**
+ * @brief Callback function type for iterating over key-value pairs in a table.
+ * @param key The current key (null-terminated string).
+ * @param value A pointer to the current mongory_value.
+ * @param acc An accumulator or context pointer passed through the iteration.
+ * @return bool Return true to continue iteration, false to stop.
+ */
+typedef bool (*mongory_table_each_pair_callback_func)(char *key, mongory_value *value, void *acc);
+
+/**
+ * @brief Function pointer type for retrieving a value by its key.
+ * @param self A pointer to the mongory_table instance.
+ * @param key The null-terminated string key.
+ * @return mongory_value* A pointer to the mongory_value associated with the
+ * key, or NULL if the key is not found.
+ */
+typedef mongory_value *(*mongory_table_get_func)(mongory_table *self, char *key);
+
+/**
+ * @brief Function pointer type for setting (adding or updating) a key-value
+ * pair.
+ * @param self A pointer to the mongory_table instance.
+ * @param key The null-terminated string key. The table will make its own copy
+ * of this key.
+ * @param value A pointer to the mongory_value to associate with the key.
+ * @return bool True if the operation was successful, false otherwise (e.g.,
+ * memory allocation failure).
+ */
+typedef bool (*mongory_table_set_func)(mongory_table *self, char *key, mongory_value *value);
+
+/**
+ * @brief Function pointer type for iterating over all key-value pairs in the
+ * table.
+ * @param self A pointer to the mongory_table instance.
+ * @param acc An accumulator or context pointer to be passed to the callback.
+ * @param callback The function to be executed for each key-value pair.
+ * @return bool True if the iteration completed fully, false if it was stopped
+ * by a callback.
+ */
+typedef bool (*mongory_table_each_func)(mongory_table *self, void *acc, mongory_table_each_pair_callback_func callback);
+
+/**
+ * @brief Function pointer type for deleting a key-value pair from the table.
+ * @param self A pointer to the mongory_table instance.
+ * @param key The null-terminated string key of the pair to delete.
+ * @return bool True if the key was found and deleted, false otherwise.
+ */
+typedef bool (*mongory_table_del_func)(mongory_table *self, char *key);
+
+/**
+ * @brief Creates a new mongory_table instance.
+ *
+ * Initializes the hash table with a default capacity and associates it with the
+ * provided memory pool for all internal allocations.
+ *
+ * @param pool A pointer to the mongory_memory_pool to be used for allocations.
+ * @return mongory_table* A pointer to the newly created mongory_table, or NULL
+ * if creation fails (e.g., memory allocation failure).
+ */
+mongory_table *mongory_table_new(mongory_memory_pool *pool);
+
+/**
+ * @brief Creates a new mongory_table instance with a nested table.
+ *
+ * This function is used to create a new mongory_table instance with a nested
+ * table. The nested table is created with the given memory pool and the given
+ * key-value pairs. The nested table is returned as a pointer to the
+ * mongory_table structure.
+ *
+ * @param pool A pointer to the mongory_memory_pool to be used for allocations.
+ * @param argc The number of key-value pairs to be set.
+ * @param ... The key-value pairs to be set.
+ * @return mongory_table* A pointer to the newly created mongory_table, or NULL
+ * if creation fails (e.g., memory allocation failure).
+ */
+mongory_table *mongory_table_nested_wrap(mongory_memory_pool *pool, int argc, ...);
+#define MG_TABLE_WRAP(pool, n, ...) mongory_value_wrap_t(pool, mongory_table_nested_wrap(pool, n, __VA_ARGS__))
+
+/**
+ * @struct mongory_table
+ * @brief Represents a hash table mapping string keys to mongory_value pointers.
+ *
+ * Provides function pointers for common table operations, similar to an
+ * object-oriented interface. The `count` field indicates the number of
+ * key-value pairs currently in the table and should be treated as read-only by
+ * users of the table.
+ */
+struct mongory_table {
+  mongory_memory_pool *pool;    /**< The memory pool used for allocations. */
+  size_t count;                 /**< Read-only. The current number of key-value pairs in the
+                                   table. */
+  mongory_table_get_func get;   /**< Function to get a value by key. */
+  mongory_table_each_func each; /**< Function to iterate over key-value pairs. */
+  mongory_table_set_func set;   /**< Function to set a key-value pair. */
+  mongory_table_del_func del;   /**< Function to delete a key-value pair. */
+};
+
+mongory_table *mongory_table_merge(mongory_table *table, mongory_table *other);
+
+#endif /* MONGORY_TABLE_H */

data/ext/mongory_ext/mongory-core/include/mongory-core/foundations/value.h

@@ -0,0 +1,175 @@
+#ifndef MONGORY_VALUE
+#define MONGORY_VALUE
+
+/**
+ * @file value.h
+ * @brief Defines the mongory_value structure, a generic value type for the
+ * Mongory library.
+ *
+ * `mongory_value` is a tagged union that can represent various data types such
+ * as null, boolean, integer, double, string, array, table, regex, pointers,
+ * and an unsupported type. It includes functions for wrapping C types into
+ * `mongory_value` objects, comparing values, and converting them to strings.
+ */
+
+#include "mongory-core/foundations/memory_pool.h"
+#include <stdbool.h>
+#include <stdint.h> // For int64_t
+
+// Forward declarations for complex types that can be stored in mongory_value.
+struct mongory_array;
+struct mongory_table;
+
+// Forward declaration of mongory_value itself and its type enum.
+struct mongory_value;
+/**
+ * @brief Alias for `struct mongory_value`.
+ */
+typedef struct mongory_value mongory_value;
+
+enum mongory_type;
+/**
+ * @brief Alias for `enum mongory_type`.
+ */
+typedef enum mongory_type mongory_type;
+
+/**
+ * @brief Function pointer type for comparing two mongory_value instances.
+ *
+ * @param a The first mongory_value.
+ * @param b The second mongory_value.
+ * @return int Returns:
+ *         - 0 if a is equal to b.
+ *         - A negative value if a is less than b.
+ *         - A positive value if a is greater than b.
+ *         - `mongory_value_compare_fail` (a specific constant) if the types
+ *           are incompatible for comparison or an error occurs.
+ */
+typedef int (*mongory_value_compare_func)(mongory_value *a, mongory_value *b);
+
+/**
+ * @brief Function pointer type for converting a mongory_value to a string representation.
+ * @param value The mongory_value to convert.
+ * @param pool The memory pool to allocate from.
+ * @return char* A string literal representing the value, or NULL if allocation
+ * fails. The string is a literal and should not be freed.
+ */
+typedef char *(*mongory_value_to_str_func)(mongory_value *value, mongory_memory_pool *pool);
+
+/**
+ * @brief Converts the type of a mongory_value to its string representation.
+ * @param value A pointer to the mongory_value.
+ * @return char* A string literal representing the type (e.g., "Int", "String").
+ * Returns "UnknownType" if the type is not recognized. This string is a
+ * literal and should not be freed.
+ */
+char *mongory_type_to_string(mongory_value *value);
+
+/**
+ * @brief Extracts a pointer to the raw data stored within a mongory_value.
+ * The type of the returned pointer depends on the `mongory_value`'s type.
+ * For example, for an MONGORY_TYPE_INT, it returns `int64_t*`.
+ * @param value A pointer to the mongory_value.
+ * @return void* A pointer to the internal data, or NULL if the type is unknown
+ * or has no direct data pointer (e.g. MONGORY_TYPE_NULL).
+ */
+void *mongory_value_extract(mongory_value *value);
+
+/** @name Mongory Value Wrapper Functions
+ *  Functions to create mongory_value instances from basic C types.
+ *  These functions allocate a new mongory_value from the provided pool.
+ *  @{
+ */
+mongory_value *mongory_value_wrap_n(mongory_memory_pool *pool, void *n);
+mongory_value *mongory_value_wrap_b(mongory_memory_pool *pool, bool b);
+mongory_value *mongory_value_wrap_i(mongory_memory_pool *pool, int64_t i);
+mongory_value *mongory_value_wrap_d(mongory_memory_pool *pool, double d);
+mongory_value *mongory_value_wrap_s(mongory_memory_pool *pool, char *s);
+mongory_value *mongory_value_wrap_a(mongory_memory_pool *pool, struct mongory_array *a);
+mongory_value *mongory_value_wrap_t(mongory_memory_pool *pool, struct mongory_table *t);
+mongory_value *mongory_value_wrap_regex(mongory_memory_pool *pool, void *regex);
+mongory_value *mongory_value_wrap_ptr(mongory_memory_pool *pool, void *ptr);
+mongory_value *mongory_value_wrap_u(mongory_memory_pool *pool, void *u);
+/** @} */
+
+/**
+ * @def MONGORY_TYPE_MACRO
+ * @brief X-Macro for defining mongory_type enum members and associated data.
+ * Simplifies the definition of types, their string names, and corresponding
+ * union fields.
+ * _(ENUM_NAME, UNIQUE_NUM_SUFFIX, "STRING_NAME", UNION_FIELD_NAME)
+ * Note: For MONGORY_TYPE_NULL, the 'i' field (int64_t) is arbitrarily used in
+ * the macro as the union needs a field, but it's not meaningful for null.
+ */
+#define MONGORY_TYPE_MACRO(_)                                                                                          \
+  _(MONGORY_TYPE_NULL, 0, "Null", i) /* Field 'i' is arbitrary for NULL */                                             \
+  _(MONGORY_TYPE_BOOL, 10, "Bool", b)                                                                                  \
+  _(MONGORY_TYPE_INT, 11, "Int", i)                                                                                    \
+  _(MONGORY_TYPE_DOUBLE, 12, "Double", d)                                                                              \
+  _(MONGORY_TYPE_STRING, 13, "String", s)                                                                              \
+  _(MONGORY_TYPE_ARRAY, 14, "Array", a)                                                                                \
+  _(MONGORY_TYPE_TABLE, 15, "Table", t)                                                                                \
+  _(MONGORY_TYPE_REGEX, 16, "Regex", regex)          /* Custom regex object pointer */                                 \
+  _(MONGORY_TYPE_POINTER, 17, "Pointer", ptr)        /* Generic void pointer */                                        \
+  _(MONGORY_TYPE_UNSUPPORTED, 999, "Unsupported", u) /* External/unknown type pointer */
+
+/**
+ * @def MONGORY_ENUM_MAGIC
+ * @brief A magic number used in generating enum values for mongory_type.
+ * Helps in creating somewhat unique integer values for the enums.
+ */
+#define MONGORY_ENUM_MAGIC 103
+
+/**
+ * @enum mongory_type
+ * @brief Enumerates the possible data types a mongory_value can hold.
+ * Values are generated using MONGORY_TYPE_MACRO and MONGORY_ENUM_MAGIC.
+ */
+enum mongory_type {
+#define DEFINE_ENUM(name, num, str, field) name = num * MONGORY_ENUM_MAGIC,
+  MONGORY_TYPE_MACRO(DEFINE_ENUM)
+#undef DEFINE_ENUM
+};
+
+/**
+ * @var mongory_value_compare_fail
+ * @brief Special return value from compare functions indicating comparison
+ * failure (e.g. incompatible types).
+ */
+static const int mongory_value_compare_fail = 97;
+
+/**
+ * @struct mongory_value
+ * @brief Represents a generic value in the Mongory system.
+ *
+ * It's a tagged union, where `type` indicates which field in the `data` union
+ * is active. Each value also carries a pointer to the `mongory_memory_pool`
+ * it was allocated from (or is associated with) and a `comp` function for
+ * comparisons. The `origin` field can be used to store a pointer to an
+ * original external data structure if the `mongory_value` is a bridge or
+ * wrapper.
+ */
+struct mongory_value {
+  mongory_memory_pool *pool;        /**< Memory pool associated with this value. */
+  mongory_type type;                /**< The type of data stored in the union. */
+  mongory_value_compare_func comp;  /**< Function to compare this value with
+                                       another. */
+  mongory_value_to_str_func to_str; /**< Function to convert this value to a
+                                      string representation. */
+  union {
+    bool b;                  /**< Boolean data. */
+    int64_t i;               /**< Integer data (64-bit). */
+    double d;                /**< Double-precision floating-point data. */
+    char *s;                 /**< String data (null-terminated). String memory
+                                is typically managed by the pool. */
+    struct mongory_array *a; /**< Pointer to a mongory_array. */
+    struct mongory_table *t; /**< Pointer to a mongory_table. */
+    void *regex;             /**< Pointer to a custom regex object/structure. */
+    void *ptr;               /**< Generic void pointer for other data. */
+    void *u;                 /**< Pointer for unsupported/external types. */
+  } data;                    /**< Union holding the actual data based on type. */
+  void *origin;              /**< Optional pointer to an original external value, useful for
+                                bridging with other data systems. */
+};
+
+#endif /* MONGORY_VALUE */

data/ext/mongory_ext/mongory-core/include/mongory-core/matchers/matcher.h

@@ -0,0 +1,76 @@
+#ifndef MONGORY_MATCHER_H
+#define MONGORY_MATCHER_H
+
+/**
+ * @file matcher.h
+ * @brief Defines the core mongory_matcher structure and related types.
+ *
+ * This file provides the basic structure for all matchers in the Mongory
+ * library. A matcher is responsible for determining if a given `mongory_value`
+ * meets certain criteria defined by a `condition`.
+ */
+
+#include "mongory-core/foundations/array.h" // For mongory_array (used in context)
+#include "mongory-core/foundations/memory_pool.h"
+#include "mongory-core/foundations/value.h"
+
+// Forward declaration for the main matcher structure.
+typedef struct mongory_matcher mongory_matcher;
+/**
+ * @brief Creates a new generic matcher instance.
+ *
+ * This function typically serves as a high-level entry point for creating
+ * matchers. In the current implementation, it delegates to
+ * `mongory_matcher_table_cond_new`, implying that conditions are often
+ * table-based (similar to query documents).
+ *
+ * @param pool The memory pool to use for the matcher's allocations.
+ * @param condition A `mongory_value` representing the condition for this
+ * matcher.
+ * @return mongory_matcher* A pointer to the newly created matcher, or NULL on
+ * failure.
+ */
+mongory_matcher *mongory_matcher_new(mongory_memory_pool *pool, mongory_value *condition, void *extern_ctx);
+
+/**
+ * @brief Matches a value against a matcher.
+ * @param matcher The matcher to match against.
+ * @param value The value to match.
+ * @return True if the value matches the matcher, false otherwise.
+ */
+bool mongory_matcher_match(mongory_matcher *matcher, mongory_value *value);
+
+/**
+ * @brief Explains a matcher.
+ * @param matcher The matcher to explain.
+ * @param temp_pool The temporary pool to use for the explanation.
+ */
+void mongory_matcher_explain(mongory_matcher *matcher, mongory_memory_pool *temp_pool);
+
+/**
+ * @brief Traces a matcher.
+ * @param matcher The matcher to trace.
+ * @param value The value to trace.
+ */
+bool mongory_matcher_trace(mongory_matcher *matcher, mongory_value *value);
+
+/**
+ * @brief Prints the trace of a matcher.
+ * @param matcher The matcher to print the trace of.
+ */
+void mongory_matcher_print_trace(mongory_matcher *matcher);
+
+/**
+ * @brief Enables the trace of a matcher.
+ * @param matcher The matcher to enable the trace of.
+ * @param temp_pool The temporary pool to use for the trace.
+ */
+void mongory_matcher_enable_trace(mongory_matcher *matcher, mongory_memory_pool *temp_pool);
+
+/**
+ * @brief Disables the trace of a matcher.
+ * @param matcher The matcher to disable the trace of.
+ */
+void mongory_matcher_disable_trace(mongory_matcher *matcher);
+
+#endif /* MONGORY_MATCHER_H */

data/ext/mongory_ext/mongory-core/include/mongory-core.h

@@ -0,0 +1,12 @@
+#ifndef MONGORY_CORE_H
+#define MONGORY_CORE_H
+
+#include "mongory-core/foundations/array.h"
+#include "mongory-core/foundations/config.h"
+#include "mongory-core/foundations/error.h"
+#include "mongory-core/foundations/memory_pool.h"
+#include "mongory-core/foundations/table.h"
+#include "mongory-core/foundations/value.h"
+#include "mongory-core/matchers/matcher.h"
+
+#endif