///
///
///
///
/**
* Type Definitions for Gjs (https://gjs.guide/)
*
* These type definitions are automatically generated, do not edit them by hand.
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
*
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
*/
declare module 'gi://Xmlb?version=2.0' {
// Module dependencies
import type Gio from 'gi://Gio?version=2.0';
import type GObject from 'gi://GObject?version=2.0';
import type GLib from 'gi://GLib?version=2.0';
import type GModule from 'gi://GModule?version=2.0';
export namespace Xmlb {
/**
* Xmlb-2.0
*/
export namespace OpcodeKind {
export const $gtype: GObject.GType;
}
enum OpcodeKind {
/**
* Unknown opcode
*/
UNKNOWN,
/**
* A literal integer value
*/
INTEGER,
/**
* A literal text value
*/
TEXT,
/**
* An operator
*/
FUNCTION,
BOUND_UNSET,
/**
* A bound integer value
*/
BOUND_INTEGER,
/**
* A bound text value
*/
BOUND_TEXT,
/**
* An indexed text value
*/
INDEXED_TEXT,
BOOLEAN,
/**
* An bound indexed text value
*/
BOUND_INDEXED_TEXT,
}
/**
* The compile-time major version
*/
const MAJOR_VERSION: number;
/**
* The compile-time micro version
*/
const MICRO_VERSION: number;
/**
* The compile-time minor version
*/
const MINOR_VERSION: number;
/**
* Converts a string to an opcode kind.
* @param str a string, e.g. `FUNC`
* @returns a #XbOpcodeKind, e.g. %XB_OPCODE_KIND_TEXT
*/
function opcode_kind_from_string(str: string): OpcodeKind;
/**
* Converts the opcode kind to a string.
* @param kind a #XbOpcodeKind, e.g. %XB_OPCODE_KIND_FUNCTION
* @returns opcode kind, e.g. `FUNC`
*/
function opcode_kind_to_string(kind: OpcodeKind | null): string;
/**
* Escapes XPath control sequences such as newlines, tabs, and forward slashes.
* @param str string, e.g. `app/org.gnome.ghex/x86_64/stable`
* @returns new string that is safe to use for queries
*/
function string_escape(str: string): string;
/**
* Gets the XMLb installed runtime version.
* @returns a version number, e.g. "0.3.19"
*/
function version_string(): string;
interface BuilderFixupFunc {
(self: BuilderFixup, bn: BuilderNode): boolean;
}
interface BuilderNodeSortFunc {
(bn1: BuilderNode, bn2: BuilderNode): number;
}
interface BuilderNodeTraverseFunc {
(bn: BuilderNode): boolean;
}
interface BuilderSourceNodeFunc {
(self: BuilderSource, bn: BuilderNode): boolean;
}
interface MachineMethodFunc {
(self: Machine, stack: Stack, result_unused: boolean, exec_data?: any | null): boolean;
}
interface MachineOpcodeFixupFunc {
(self: Machine, opcodes: Stack): boolean;
}
interface MachineTextHandlerFunc {
(self: Machine, opcodes: Stack, text: string, handled: boolean): boolean;
}
interface NodeTransmogrifyFunc {
(self: Node): boolean;
}
/**
* The flags for converting to XML.
*/
/**
* The flags for converting to XML.
*/
export namespace BuilderCompileFlags {
export const $gtype: GObject.GType;
}
enum BuilderCompileFlags {
/**
* No extra flags to use
*/
NONE,
/**
* Only load native languages
*/
NATIVE_LANGS,
/**
* Ignore invalid files without an error
*/
IGNORE_INVALID,
/**
* Only store a single language
*/
SINGLE_LANG,
/**
* Watch the XMLB file for changes
*/
WATCH_BLOB,
/**
* Ignore the cache GUID value
*/
IGNORE_GUID,
/**
* Require at most one root node
*/
SINGLE_ROOT,
}
/**
* The flags used when building a node.
*/
/**
* The flags used when building a node.
*/
export namespace BuilderNodeFlags {
export const $gtype: GObject.GType;
}
enum BuilderNodeFlags {
/**
* No extra flags to use
*/
NONE,
/**
* Do not include this node in the silo
*/
IGNORE,
/**
* Assume the node CDATA is already valid
*/
LITERAL_TEXT,
/**
* If the node has leading text
*/
HAS_TEXT,
/**
* If the node has trailing text
*/
HAS_TAIL,
/**
* Tokenize and fold text to ASCII (Since: 0.3.1)
*/
TOKENIZE_TEXT,
/**
* Strip leading and trailing spaces from text (Since:
* 0.3.4)
*/
STRIP_TEXT,
}
/**
* The flags for converting to XML.
*/
/**
* The flags for converting to XML.
*/
export namespace BuilderSourceFlags {
export const $gtype: GObject.GType;
}
enum BuilderSourceFlags {
/**
* No extra flags to use
*/
NONE,
/**
* Do not attempt to repair XML whitespace
*/
LITERAL_TEXT,
/**
* Watch the source file for changes
*/
WATCH_FILE,
/**
* Watch the directory containing the source file for
* changes (for example, if watching all the sources in a directory — this allows the file monitors
* to be shared)
*/
WATCH_DIRECTORY,
}
/**
* The flags to control the amount of debugging is generated.
*/
/**
* The flags to control the amount of debugging is generated.
*/
export namespace MachineDebugFlags {
export const $gtype: GObject.GType;
}
enum MachineDebugFlags {
/**
* No debug flags to use
*/
NONE,
/**
* Show the stack addition and removal
*/
SHOW_STACK,
/**
* Show the XPath predicate parsing
*/
SHOW_PARSING,
/**
* Show the optimizer operation
*/
SHOW_OPTIMIZER,
/**
* Show the query slow paths
*/
SHOW_SLOW_PATH,
}
/**
* The flags to control the parsing behaviour.
*/
/**
* The flags to control the parsing behaviour.
*/
export namespace MachineParseFlags {
export const $gtype: GObject.GType;
}
enum MachineParseFlags {
/**
* No flags set
*/
NONE,
/**
* Run an optimization pass on the predicate
*/
OPTIMIZE,
}
/**
* The flags for converting to XML.
*/
/**
* The flags for converting to XML.
*/
export namespace NodeExportFlags {
export const $gtype: GObject.GType;
}
enum NodeExportFlags {
/**
* No extra flags to use
*/
NONE,
/**
* Add an XML header to the data
*/
ADD_HEADER,
/**
* Split up children with a newline
*/
FORMAT_MULTILINE,
/**
* Indent the XML by child depth
*/
FORMAT_INDENT,
/**
* Include the siblings when converting
*/
INCLUDE_SIBLINGS,
/**
* Only export the children of the node
*/
ONLY_CHILDREN,
/**
* If node has no children, collapse open and close
* tags
*/
COLLAPSE_EMPTY,
}
/**
* The opcode flags. The values have been carefully chosen so that a simple
* bitmask can be done to know how to compare for equality.
*
* function─┐ ┌─string
* bound──┐ │ │ ┌──integer
* token┐ │ │ │ │
* X X X X X X X
* 8 4 2 1
*/
/**
* The opcode flags. The values have been carefully chosen so that a simple
* bitmask can be done to know how to compare for equality.
*
* function─┐ ┌─string
* bound──┐ │ │ ┌──integer
* token┐ │ │ │ │
* X X X X X X X
* 8 4 2 1
*/
export namespace OpcodeFlags {
export const $gtype: GObject.GType;
}
enum OpcodeFlags {
UNKNOWN,
/**
* Integer value set
*/
INTEGER,
/**
* Text value set
*/
TEXT,
/**
* An operator
*/
FUNCTION,
/**
* A bound value, assigned later
*/
BOUND,
BOOLEAN,
/**
* Tokenized text
*/
TOKENIZED,
}
/**
* The flags used for queries.
*/
/**
* The flags used for queries.
*/
export namespace QueryFlags {
export const $gtype: GObject.GType;
}
enum QueryFlags {
/**
* No extra flags to use
*/
NONE,
/**
* Optimize the query when possible
*/
OPTIMIZE,
/**
* Use the indexed parameters
*/
USE_INDEXES,
/**
* Reverse the results order
*/
REVERSE,
/**
* Always cache the #XbNode objects
*/
FORCE_NODE_CACHE,
}
/**
* The flags for loading a silo.
*/
/**
* The flags for loading a silo.
*/
export namespace SiloLoadFlags {
export const $gtype: GObject.GType;
}
enum SiloLoadFlags {
/**
* No extra flags to use
*/
NONE,
/**
* No not check header signature
*/
NO_MAGIC,
/**
* Watch the XMLB file for changes
*/
WATCH_BLOB,
}
/**
* The flags used when profiling a silo.
*/
/**
* The flags used when profiling a silo.
*/
export namespace SiloProfileFlags {
export const $gtype: GObject.GType;
}
enum SiloProfileFlags {
/**
* No extra flags to use
*/
NONE,
/**
* Output profiling as debug
*/
DEBUG,
/**
* Save profiling in an appended string
*/
APPEND,
/**
* Save XPATH queries
*/
XPATH,
/**
* Output the machine optimizer as debug
*/
OPTIMIZER,
}
namespace Builder {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
class Builder extends GObject.Object {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): Builder;
// Methods
/**
* Adds a function that will get run on every #XbBuilderNode compile creates
* for the silo. This is run after all the #XbBuilderSource fixups have been
* run.
* @param fixup a #XbBuilderFixup
*/
add_fixup(fixup: BuilderFixup): void;
/**
* Adds a locale to the builder. Locales added first will be prioritised over
* locales added later.
* @param locale a locale, e.g. "en_US"
*/
add_locale(locale: string): void;
/**
* Adds the GUID to the internal correctness hash.
* @param guid any text, typcically a filename or GUID
*/
append_guid(guid: string): void;
/**
* Compiles a #XbSilo.
* @param flags some #XbBuilderCompileFlags, e.g. %XB_BUILDER_SOURCE_FLAG_LITERAL_TEXT
* @param cancellable a #GCancellable, or %NULL
* @returns a #XbSilo, or %NULL for error
*/
compile(flags: BuilderCompileFlags | null, cancellable?: Gio.Cancellable | null): Silo;
/**
* Ensures `file` is up to date, and returns a compiled #XbSilo.
*
* If `silo` is being used by a query (e.g. in another thread) then all node
* data is immediately invalid.
*
* The returned #XbSilo will use the thread-default main context at the time of
* calling this function for its future signal emissions.
* @param file a #GFile
* @param flags some #XbBuilderCompileFlags, e.g. %XB_BUILDER_COMPILE_FLAG_IGNORE_INVALID
* @param cancellable a #GCancellable, or %NULL
* @returns a #XbSilo, or %NULL for error
*/
ensure(file: Gio.File, flags: BuilderCompileFlags | null, cancellable?: Gio.Cancellable | null): Silo;
/**
* Adds a node tree to the builder.
*
* If you are manually adding dynamic data sourced from a non-static source then you MUST use
* xb_builder_append_guid() with the appropriate GUID value, e.g. the file name and mtime.
*
* If no appropriate value is available, the caller can use something like:
*
* g_autofree gchar *tmp = xb_builder_node_export(bn, XB_NODE_EXPORT_FLAG_NONE, NULL);
* xb_builder_append_guid(builder, tmp);
*
* Failure to include an appropriate GUID value would allow an out-of-data silo to be used.
* @param bn a #XbBuilderNode
*/
import_node(bn: BuilderNode): void;
/**
* Adds a #XbBuilderSource to the #XbBuilder.
* @param source a #XbBuilderSource
*/
import_source(source: BuilderSource): void;
/**
* Enables or disables the collection of profiling data.
* @param profile_flags some #XbSiloProfileFlags, e.g. %XB_SILO_PROFILE_FLAG_DEBUG
*/
set_profile_flags(profile_flags: SiloProfileFlags | null): void;
}
namespace BuilderFixup {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
class BuilderFixup extends GObject.Object {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](id: string, func: BuilderFixupFunc): BuilderFixup;
// Methods
/**
* Gets the maximum depth used for this fixup, if each node is being visited.
* @returns integer, or -1 if unset
*/
get_max_depth(): number;
/**
* Sets the maximum depth used for this fixup. Use a `max_depth` of 0 to only
* visit the root node.
*
* Setting a maximum depth may increase performance considerably if using
* fixup functions on large and deeply nested XML files.
* @param max_depth integer, -1 for "all"
*/
set_max_depth(max_depth: number): void;
}
namespace BuilderNode {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
class BuilderNode extends GObject.Object {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](element: string): BuilderNode;
// Methods
/**
* Adds a child builder node.
* @param child A XbBuilderNode
*/
add_child(child: BuilderNode): void;
/**
* Adds a flag to the builder node.
* @param flag a #XbBuilderNodeFlags
*/
add_flag(flag: BuilderNodeFlags | null): void;
/**
* Adds a token to the builder node.
* @param token a new token
*/
add_token(token: string): void;
/**
* Gets the depth of the node tree, where 0 is the root node.
*/
depth(): number;
/**
* Exports the node to XML.
* @param flags some #XbNodeExportFlags, e.g. #XB_NODE_EXPORT_FLAG_NONE
* @returns XML data, or %NULL for an error
*/
['export'](flags: NodeExportFlags | null): string;
/**
* Gets an attribute from the builder node.
* @param name attribute name, e.g. `type`
* @returns string, or %NULL if unset
*/
get_attr(name: string): string;
/**
* Gets an attribute from the builder node.
* @param name attribute name, e.g. `priority`
* @returns integer, or 0 if unset
*/
get_attr_as_uint(name: string): number;
/**
* Finds a child builder node by the element name, and optionally text value.
* @param element An element name, e.g. "url"
* @param text node text, e.g. "gimp.desktop"
* @returns a new #XbBuilderNode, or %NULL if not found
*/
get_child(element: string, text?: string | null): BuilderNode;
/**
* Gets the children of the builder node.
* @returns children
*/
get_children(): BuilderNode[];
/**
* Gets the element from the builder node.
* @returns string, or %NULL if unset
*/
get_element(): string;
/**
* Gets the first child of the builder node.
* @returns a #XbBuilderNode, or %NULL
*/
get_first_child(): BuilderNode;
/**
* Gets the last child of the builder node.
* @returns a #XbBuilderNode, or %NULL
*/
get_last_child(): BuilderNode;
/**
* Gets the parent node for the current node.
* @returns a new #XbBuilderNode, or %NULL no parent exists.
*/
get_parent(): BuilderNode;
/**
* Gets the tail from the builder node.
* @returns string, or %NULL if unset
*/
get_tail(): string;
/**
* Gets the text from the builder node.
* @returns string, or %NULL if unset
*/
get_text(): string;
/**
* Gets the text from the builder node.
* @returns integer, or 0 if unset
*/
get_text_as_uint(): number;
/**
* Gets the tokens of the builder node.
* @returns tokens
*/
get_tokens(): string[] | null;
/**
* Checks a flag on the builder node.
* @param flag a #XbBuilderNodeFlags
* @returns %TRUE if @flag is set
*/
has_flag(flag: BuilderNodeFlags | null): boolean;
/**
* Removes an attribute from the builder node.
* @param name attribute name, e.g. `type`
*/
remove_attr(name: string): void;
/**
* Removes a child builder node.
* @param child A XbBuilderNode
*/
remove_child(child: BuilderNode): void;
/**
* Adds an attribute to the builder node.
* @param name attribute name, e.g. `type`
* @param value attribute value, e.g. `desktop`
*/
set_attr(name: string, value: string): void;
/**
* Sets the element name on the builder node.
* @param element a string element
*/
set_element(element: string): void;
/**
* Sets the tail on the builder node.
* @param tail a string
* @param tail_len length of @tail, or -1 if @tail is NUL terminated
*/
set_tail(tail: string | null, tail_len: number): void;
/**
* Sets the text on the builder node.
* @param text a string
* @param text_len length of @text, or -1 if @text is NUL terminated
*/
set_text(text: string | null, text_len: number): void;
/**
* Sorts the node children using a custom sort function.
* @param func a #XbBuilderNodeSortFunc
*/
sort_children(func: BuilderNodeSortFunc): void;
/**
* Tokenize text added with xb_builder_node_set_text().
*
* When searching, libxmlb often has to tokenize strings before they can be
* compared. This is done in the "fast path" and makes searching for non-ASCII
* text much slower.
*
* Adding the tokens to the deduplicated string table allows much faster
* searching at the expense of a ~5% size increase of the silo.
*
* This function adds all valid UTF-8 and ASCII search words generated from
* the value of xb_builder_node_set_text().
*
* The transliteration locale (e.g. `en_GB`) is read from the `xml:lang`
* node attribute if set.
*/
tokenize_text(): void;
/**
* Traverses a tree starting from `self`. It calls the given function for each
* node visited.
*
* The traversal can be halted at any point by returning TRUE from `func`.
* @param order a #GTraverseType, e.g. %G_PRE_ORDER
* @param flags a #GTraverseFlags, e.g. %G_TRAVERSE_ALL
* @param max_depth the maximum depth of the traversal, or -1 for no limit
* @param func a #XbBuilderNodeTraverseFunc
*/
traverse(
order: GLib.TraverseType | null,
flags: GLib.TraverseFlags | null,
max_depth: number,
func: BuilderNodeTraverseFunc,
): void;
/**
* Unlinks a #XbBuilderNode from a tree, resulting in two separate trees.
*
* This should not be used from the function called by xb_builder_node_traverse()
* otherwise the entire tree will not be traversed.
*
* Instead use xb_builder_node_add_flag(bn,XB_BUILDER_NODE_FLAG_IGNORE);
*/
unlink(): void;
}
namespace BuilderSource {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
class BuilderSource extends GObject.Object {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): BuilderSource;
// Methods
/**
* Adds a function that will get run on every #XbBuilderNode compile creates
* with this source.
* @param fixup a #XbBuilderFixup
*/
add_fixup(fixup: BuilderFixup): void;
/**
* Loads XML data and begins to build a #XbSilo.
* @param bytes a #GBytes
* @param flags some #XbBuilderSourceFlags, e.g. %XB_BUILDER_SOURCE_FLAG_LITERAL_TEXT
* @returns %TRUE for success
*/
load_bytes(bytes: GLib.Bytes | Uint8Array, flags: BuilderSourceFlags | null): boolean;
/**
* Loads an optionally compressed XML file to build a #XbSilo.
* @param file a #GFile
* @param flags some #XbBuilderSourceFlags, e.g. %XB_BUILDER_SOURCE_FLAG_LITERAL_TEXT
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE for success
*/
load_file(file: Gio.File, flags: BuilderSourceFlags | null, cancellable?: Gio.Cancellable | null): boolean;
/**
* Loads XML data and begins to build a #XbSilo.
* @param xml XML data
* @param flags some #XbBuilderSourceFlags, e.g. %XB_BUILDER_SOURCE_FLAG_LITERAL_TEXT
* @returns %TRUE for success
*/
load_xml(xml: string, flags: BuilderSourceFlags | null): boolean;
/**
* Sets an optional information metadata node on the root node.
* @param info a #XbBuilderNode
*/
set_info(info?: BuilderNode | null): void;
/**
* Sets an optional prefix on the root node. This makes any nodes added
* using this source reside under a common shared parent node.
* @param prefix an XPath prefix, e.g. `installed`
*/
set_prefix(prefix?: string | null): void;
}
namespace BuilderSourceCtx {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
class BuilderSourceCtx extends GObject.Object {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Returns the data currently being processed.
*
* If the #XbBuilderSourceCtx is backed by a file, the returned #GBytes may be
* memory-mapped, and the backing file must not be modified until the #GBytes is
* destroyed.
* @param cancellable a #GCancellable, or %NULL
* @returns a #GBytes
*/
get_bytes(cancellable?: Gio.Cancellable | null): GLib.Bytes;
/**
* Returns the basename of the file currently being processed.
* @returns a basename, or %NULL if unset
*/
get_filename(): string | null;
/**
* Returns the input stream currently being processed.
* @returns a #GInputStream
*/
get_stream(): Gio.InputStream;
}
namespace Machine {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
class Machine extends GObject.Object {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): Machine;
// Methods
/**
* Adds a new function to the virtual machine. Registered functions can then be
* used as methods.
*
* The `method_cb` must not modify the stack it’s passed unless it’s going to
* succeed. In particular, if a method call is not optimisable, it must not
* modify the stack it’s passed.
*
* You need to add a custom function using xb_machine_add_method() before using
* methods that may reference it, for example xb_machine_add_opcode_fixup().
* @param name function name, e.g. `contains`
* @param n_opcodes minimum number of opcodes required on the stack
* @param method_cb function to call
*/
add_method(name: string, n_opcodes: number, method_cb: MachineMethodFunc): void;
/**
* Adds an opcode fixup. Fixups can be used to optimize the stack of opcodes or
* to add support for a nonstandard feature, for instance supporting missing
* attributes to functions.
* @param opcodes_sig signature, e.g. `INTE,TEXT`
* @param fixup_cb callback
*/
add_opcode_fixup(opcodes_sig: string, fixup_cb: MachineOpcodeFixupFunc): void;
/**
* Adds a new operator to the virtual machine. Operators can then be used
* instead of explicit methods like `eq()`.
*
* You need to add a custom operator using xb_machine_add_operator() before
* using xb_machine_parse(). Common operators like `<=` and `=` are built-in
* and do not have to be added manually.
* @param str operator string, e.g. `==`
* @param name function name, e.g. `contains`
*/
add_operator(str: string, name: string): void;
/**
* Adds a text handler. This allows the virtual machine to support nonstandard
* encoding or shorthand mnemonics for standard functions.
* @param handler_cb callback
*/
add_text_handler(handler_cb: MachineTextHandlerFunc): void;
/**
* Gets the maximum stack size used for the machine.
* @returns integer
*/
get_stack_size(): number;
/**
* Initialises a stack allocated #XbOpcode for a registered function.
* Some standard functions are registered by default, for instance `eq` or `ge`.
* Other functions have to be added using xb_machine_add_method().
* @param func_name function name, e.g. `eq`
* @returns %TRUE if the function was found and the opcode initialised, %FALSE otherwise
*/
opcode_func_init(func_name: string): [boolean, Opcode];
/**
* Parses an XPath predicate. Not all of XPath 1.0 or XPath 1.0 is supported,
* and new functions and mnemonics can be added using xb_machine_add_method()
* and xb_machine_add_text_handler().
* @param text predicate to parse, e.g. `contains(text(),'xyx')`
* @param text_len length of @text, or -1 if @text is `NUL` terminated
* @returns opcodes, or %NULL on error
*/
parse(text: string, text_len: number): Stack;
/**
* Parses an XPath predicate. Not all of XPath 1.0 or XPath 1.0 is supported,
* and new functions and mnemonics can be added using xb_machine_add_method()
* and xb_machine_add_text_handler().
* @param text predicate to parse, e.g. `contains(text(),'xyx')`
* @param text_len length of @text, or -1 if @text is `NUL` terminated
* @param flags #XbMachineParseFlags, e.g. %XB_MACHINE_PARSE_FLAG_OPTIMIZE
* @returns opcodes, or %NULL on error
*/
parse_full(text: string, text_len: number, flags: MachineParseFlags | null): Stack;
/**
* Runs a set of opcodes on the virtual machine.
*
* It is safe to call this function from a different thread to the one that
* created the #XbMachine.
* @param opcodes a #XbStack of opcodes
* @param exec_data per-run user data that is passed to all the #XbMachineMethodFunc functions
* @returns a new #XbOpcode, or %NULL
*/
run(opcodes: Stack, exec_data?: any | null): [boolean, boolean];
/**
* Runs a set of opcodes on the virtual machine, using the bound values given in
* `bindings` to substitute for bound opcodes.
*
* It is safe to call this function from a different thread to the one that
* created the #XbMachine.
* @param opcodes a #XbStack of opcodes
* @param bindings values bound to opcodes of type %XB_OPCODE_KIND_BOUND_INTEGER or %XB_OPCODE_KIND_BOUND_TEXT, or %NULL if the query doesn’t need any bound values
* @param exec_data per-run user data that is passed to all the #XbMachineMethodFunc functions
* @returns a new #XbOpcode, or %NULL
*/
run_with_bindings(
opcodes: Stack,
bindings: ValueBindings | null,
exec_data?: any | null,
): [boolean, boolean];
/**
* Sets the debug level of the virtual machine.
* @param flags #XbMachineDebugFlags, e.g. %XB_MACHINE_DEBUG_FLAG_SHOW_STACK
*/
set_debug_flags(flags: MachineDebugFlags | null): void;
/**
* Sets the maximum stack size used for the machine.
*
* The stack size will be affective for new jobs started with xb_machine_run()
* and xb_machine_parse().
* @param stack_size integer
*/
set_stack_size(stack_size: number): void;
/**
* Pops an opcode from the stack.
* @param stack a #XbStack
* @returns %TRUE if popping succeeded, %FALSE if the stack was empty already
*/
stack_pop(stack: Stack): [boolean, Opcode | null];
/**
* Pushes a new empty opcode onto the end of the stack. A pointer to the opcode
* is returned in `opcode_out` so that the caller can initialise it.
*
* If the stack reaches its maximum size, %G_IO_ERROR_NO_SPACE will be returned.
* @param stack a #XbStack
* @returns %TRUE if a new empty opcode was returned, or %FALSE if the stack has reached its maximum size
*/
stack_push(stack: Stack): [boolean, Opcode | null];
/**
* Adds an integer literal to the stack.
*
* Errors are as for xb_machine_stack_push().
* @param stack a #XbStack
* @param val integer literal
* @returns %TRUE on success, %FALSE otherwise
*/
stack_push_integer(stack: Stack, val: number): boolean;
/**
* Adds a text literal to the stack, copying `str`.
*
* Errors are as for xb_machine_stack_push().
* @param stack a #XbStack
* @param str text literal
* @returns %TRUE on success, %FALSE otherwise
*/
stack_push_text(stack: Stack, str: string): boolean;
/**
* Adds static text literal to the stack.
*
* Errors are as for xb_machine_stack_push().
* @param stack a #XbStack
* @param str text literal
* @returns %TRUE on success, %FALSE otherwise
*/
stack_push_text_static(stack: Stack, str: string): boolean;
/**
* Adds a stolen text literal to the stack.
*
* Errors are as for xb_machine_stack_push().
* @param stack a #XbStack
* @param str text literal
* @returns %TRUE on success, %FALSE otherwise
*/
stack_push_text_steal(stack: Stack, str: string): boolean;
}
namespace Node {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
class Node extends GObject.Object {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
// Methods
/**
* Exports the node back to XML.
* @param flags some #XbNodeExportFlags, e.g. #XB_NODE_EXPORT_FLAG_NONE
* @returns XML data, or %NULL for an error
*/
['export'](flags: NodeExportFlags | null): string;
/**
* Gets some attribute text data for a specific node.
* @param name an attribute name, e.g. "type"
* @returns a string, or %NULL for unset
*/
get_attr(name: string): string;
/**
* Gets some attribute text data for a specific node.
* @param name an attribute name, e.g. `type`
* @returns a guint64, or %G_MAXUINT64 if unfound
*/
get_attr_as_uint(name: string): number;
/**
* Gets the first child node for the current node.
* @returns a #XbNode, or %NULL
*/
get_child(): Node;
/**
* Gets all the children for the current node.
* @returns an array of children
*/
get_children(): Node[];
/**
* Gets any data that has been set on the node using xb_node_set_data().
*
* This will only work across queries to the associated silo if the silo has
* its #XbSilo:enable-node-cache property set to %TRUE. Otherwise a new #XbNode
* may be constructed for future queries which return the same element as a
* result.
* @param key a string key, e.g. `fwupd::RemoteId`
* @returns a #GBytes, or %NULL if not found
*/
get_data(key: string): GLib.Bytes;
// Conflicted with GObject.Object.get_data
get_data(...args: never[]): any;
/**
* Gets the depth of the node to a root.
* @returns a integer, where 0 is the root node itself.
*/
get_depth(): number;
/**
* Gets the element name for a specific node.
* @returns a string, or %NULL for the root node
*/
get_element(): string;
/**
* Gets the next sibling node for the current node.
* @returns a #XbNode, or %NULL
*/
get_next(): Node;
/**
* Gets the parent node for the current node.
* @returns a #XbNode, or %NULL
*/
get_parent(): Node;
/**
* Gets the root node for the node.
* @returns a #XbNode, or %NULL
*/
get_root(): Node;
/**
* Gets the #XbSilo for the node.
* @returns a #XbSilo
*/
get_silo(): Silo;
/**
* Gets the tail data for a specific node.
* @returns a string, or %NULL for unset
*/
get_tail(): string;
/**
* Gets the text data for a specific node.
* @returns a string, or %NULL for unset
*/
get_text(): string;
/**
* Gets some attribute text data for a specific node.
* @returns a guint64, or %G_MAXUINT64 if unfound
*/
get_text_as_uint(): number;
/**
* Searches the silo using an XPath query, returning up to `limit` results.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param xpath an XPath, e.g. `id[abe.desktop]`
* @param limit maximum number of results to return, or 0 for "all"
* @returns results, or %NULL if unfound
*/
query(xpath: string, limit: number): Node[];
/**
* Searches the node using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param xpath An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @param name an attribute name, e.g. `type`
* @returns a string, or %NULL if unfound
*/
query_attr(xpath: string, name: string): string;
/**
* Searches the node using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param xpath An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @param name an attribute name, e.g. `type`
* @returns a #guint64, or %G_MAXUINT64 if unfound
*/
query_attr_as_uint(xpath: string, name: string): number;
/**
* Searches the node using an XPath query, returning an XML string of the
* result and any children.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param xpath An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @returns a string, or %NULL if unfound
*/
query_export(xpath: string): string;
/**
* Searches the node using an XPath query, returning up to one result.
*
* Please note: Only a tiny subset of XPath 1.0 is supported.
* @param xpath An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @returns a #XbNode, or %NULL if unfound
*/
query_first(xpath: string): Node;
/**
* Searches the silo using a prepared query, returning up to one result. To
* search using a query with bound values, use
* xb_node_query_first_with_context().
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param query an #XbQuery
* @returns a #XbNode, or %NULL if unfound
*/
query_first_full(query: Query): Node;
/**
* Searches the silo using a prepared query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param query an #XbQuery
* @param context context including values bound to opcodes of type %XB_OPCODE_KIND_BOUND_INTEGER or %XB_OPCODE_KIND_BOUND_TEXT, or %NULL if the query doesn’t need any context
* @returns a #XbNode, or %NULL if unfound
*/
query_first_with_context(query: Query, context?: QueryContext | null): Node;
/**
* Searches the silo using a prepared query. To search using a query with
* bound values, use xb_node_query_with_context().
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param query an #XbQuery
* @returns results, or %NULL if unfound
*/
query_full(query: Query): Node[];
/**
* Searches the node using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param xpath An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @returns a string, or %NULL if unfound
*/
query_text(xpath: string): string;
/**
* Searches the node using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param xpath An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @returns a #guint64, or %G_MAXUINT64 if unfound
*/
query_text_as_uint(xpath: string): number;
/**
* Searches the silo using a prepared query, substituting values from the
* bindings in `context` for bound opcodes as needed.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param query an #XbQuery
* @param context context including values bound to opcodes of type %XB_OPCODE_KIND_BOUND_INTEGER or %XB_OPCODE_KIND_BOUND_TEXT, or %NULL if the query doesn’t need any context
* @returns results, or %NULL if unfound
*/
query_with_context(query: Query, context?: QueryContext | null): Node[];
/**
* Sets some data on the node which can be retrieved using xb_node_get_data().
*
* This will only work across queries to the associated silo if the silo has
* its #XbSilo:enable-node-cache property set to %TRUE. Otherwise a new #XbNode
* may be constructed for future queries which return the same element as a
* result.
* @param key a string key, e.g. `fwupd::RemoteId`
* @param data a #GBytes
*/
set_data(key: string, data: GLib.Bytes | Uint8Array): void;
// Conflicted with GObject.Object.set_data
set_data(...args: never[]): any;
/**
* Traverses a tree starting from `self`. It calls the given functions for each
* node visited. This allows transmogrification of the source, for instance
* converting the XML description to PangoMarkup or even something completely
* different like markdown.
*
* The traversal can be halted at any point by returning TRUE from `func`.
* @param func_text (allow-none): a #XbBuilderNodeTraverseFunc
* @param func_tail (allow-none): a #XbBuilderNodeTraverseFunc
* @returns %TRUE if all nodes were visited
*/
transmogrify(func_text: NodeTransmogrifyFunc, func_tail: NodeTransmogrifyFunc): boolean;
}
namespace Query {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
class Query extends GObject.Object {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](silo: Silo, xpath: string): Query;
static new_full(silo: Silo, xpath: string, flags: QueryFlags): Query;
// Methods
/**
* Assigns a string to a bound value specified using `?`.
* @param idx an integer index
* @param str string to assign to the bound variable
* @returns %TRUE if the @idx existed
*/
bind_str(idx: number, str: string): boolean;
/**
* Assigns a string to a bound value specified using `?`.
* @param idx an integer index
* @param val value to assign to the bound variable
* @returns %TRUE if the @idx existed
*/
bind_val(idx: number, val: number): boolean;
/**
* Gets the flags used for this query.
* @returns #XbQueryFlags, default %XB_QUERY_FLAG_NONE
*/
get_flags(): QueryFlags;
/**
* Gets the results limit on this query, where 0 is 'all'.
* @returns integer, default 0
*/
get_limit(): number;
/**
* Gets the XPath string that created the query.
* @returns string
*/
get_xpath(): string;
/**
* Sets the flags to use for this query.
* @param flags a #XbQueryFlags, e.g. %XB_QUERY_FLAG_USE_INDEXES
*/
set_flags(flags: QueryFlags | null): void;
/**
* Sets the results limit on this query, where 0 is 'all'.
* @param limit integer
*/
set_limit(limit: number): void;
}
namespace Silo {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {
enable_node_cache: boolean;
enableNodeCache: boolean;
guid: string;
valid: boolean;
}
}
class Silo extends GObject.Object {
static $gtype: GObject.GType;
// Properties
/**
* Whether to cache all #XbNode instances ever constructed in a single
* cache in the #XbSilo, so that the same #XbNode instance is always
* returned in query results for a given XPath. This is a form of
* memoisation, and allows xb_node_get_data() and xb_node_set_data() to
* be used.
*
* This is enabled by default to preserve compatibility with older
* versions of libxmlb, but most clients will want to disable it. It
* adds a large memory overhead (no #XbNode is ever finalised) but
* achieves moderately low hit rates for typical XML parsing workloads
* where most nodes are accessed only once or twice as they are
* processed and then processing moves on to other nodes.
*
* This property can only be changed before the #XbSilo is passed
* between threads. Changing it is not thread-safe.
*/
get enable_node_cache(): boolean;
set enable_node_cache(val: boolean);
/**
* Whether to cache all #XbNode instances ever constructed in a single
* cache in the #XbSilo, so that the same #XbNode instance is always
* returned in query results for a given XPath. This is a form of
* memoisation, and allows xb_node_get_data() and xb_node_set_data() to
* be used.
*
* This is enabled by default to preserve compatibility with older
* versions of libxmlb, but most clients will want to disable it. It
* adds a large memory overhead (no #XbNode is ever finalised) but
* achieves moderately low hit rates for typical XML parsing workloads
* where most nodes are accessed only once or twice as they are
* processed and then processing moves on to other nodes.
*
* This property can only be changed before the #XbSilo is passed
* between threads. Changing it is not thread-safe.
*/
get enableNodeCache(): boolean;
set enableNodeCache(val: boolean);
get guid(): string;
set guid(val: string);
get valid(): boolean;
// Constructors
constructor(properties?: Partial, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): Silo;
static new_from_xml(xml: string): Silo;
// Methods
/**
* Exports the silo back to XML.
* @param flags some #XbNodeExportFlags, e.g. #XB_NODE_EXPORT_FLAG_NONE
* @returns XML data, or %NULL for an error
*/
['export'](flags: NodeExportFlags | null): string;
/**
* Exports the silo back to an XML file.
* @param file a #GFile
* @param flags some #XbNodeExportFlags, e.g. #XB_NODE_EXPORT_FLAG_NONE
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE on success
*/
export_file(file: Gio.File, flags: NodeExportFlags | null, cancellable?: Gio.Cancellable | null): boolean;
/**
* Gets the backing object that created the blob.
*
* You should never *ever* modify this data.
* @returns A #GBytes, or %NULL if never set
*/
get_bytes(): GLib.Bytes;
/**
* Get #XbSilo:enable-node-cache.
*/
get_enable_node_cache(): boolean;
/**
* Gets the GUID used to identify this silo.
* @returns a string, otherwise %NULL
*/
get_guid(): string;
/**
* Returns the profiling data. This will only return profiling text if
* xb_silo_set_profile_flags() was used with %XB_SILO_PROFILE_FLAG_APPEND.
* @returns text profiling data
*/
get_profile_string(): string;
/**
* Gets the root node for the silo. (MIGHT BE MORE).
* @returns A #XbNode, or %NULL for an error
*/
get_root(): Node;
/**
* Gets the number of nodes in the silo.
* @returns a integer, or 0 is an empty blob
*/
get_size(): number;
/**
* Invalidates a silo. Future calls xb_silo_is_valid() will return %FALSE.
*/
invalidate(): void;
/**
* Checks is the silo is valid. The usual reason the silo is invalidated is
* when the backing mmapped file has changed, or one of the imported files have
* been modified.
* @returns %TRUE if valid
*/
is_valid(): boolean;
/**
* Loads a silo from memory location.
* @param blob a #GBytes
* @param flags #XbSiloLoadFlags, e.g. %XB_SILO_LOAD_FLAG_NONE
* @returns %TRUE for success, otherwise @error is set.
*/
load_from_bytes(blob: GLib.Bytes | Uint8Array, flags: SiloLoadFlags | null): boolean;
/**
* Loads a silo from file.
* @param file a #GFile
* @param flags #XbSiloLoadFlags, e.g. %XB_SILO_LOAD_FLAG_NONE
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE for success, otherwise @error is set.
*/
load_from_file(file: Gio.File, flags: SiloLoadFlags | null, cancellable?: Gio.Cancellable | null): boolean;
/**
* Create an #XbQuery from the given `xpath` XPath string, or return it from the
* query cache in the #XbSilo.
*
* `xpath` must be valid: it is a programmer error if creating the query fails
* (i.e. if xb_query_new() returns an error).
*
* This function is thread-safe.
* @param xpath an XPath query string
* @returns an #XbQuery representing @xpath
*/
lookup_query(xpath: string): Query;
/**
* Searches the silo using an XPath query, returning up to `limit` results.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param xpath an XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @param limit maximum number of results to return, or 0 for "all"
* @returns results, or %NULL if unfound
*/
query(xpath: string, limit: number): Node[];
/**
* Adds the `attr()` or `text()` results of a query to the index.
* @param xpath An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @param attr Attribute name, e.g. `type`, or NULL
* @returns %TRUE for success
*/
query_build_index(xpath: string, attr?: string | null): boolean;
/**
* Searches the silo using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a tiny subset of XPath 1.0 is supported.
* @param xpath An XPath, e.g. `/components/component[@type=desktop]/id[abe.desktop]`
* @returns a #XbNode, or %NULL if unfound
*/
query_first(xpath: string): Node;
/**
* Searches the silo using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a tiny subset of XPath 1.0 is supported.
* @param query an #XbQuery
* @returns a #XbNode, or %NULL if unfound
*/
query_first_full(query: Query): Node;
/**
* Searches the silo using an XPath query, returning up to one result.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a tiny subset of XPath 1.0 is supported.
* @param query an #XbQuery
* @param context context including values bound to opcodes of type %XB_OPCODE_KIND_BOUND_INTEGER or %XB_OPCODE_KIND_BOUND_TEXT, or %NULL if the query doesn’t need any context
* @returns a #XbNode, or %NULL if unfound
*/
query_first_with_context(query: Query, context?: QueryContext | null): Node;
/**
* Searches the silo using an XPath query.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param query an #XbQuery
* @returns results, or %NULL if unfound
*/
query_full(query: Query): Node[];
/**
* Searches the silo using an XPath query.
*
* It is safe to call this function from a different thread to the one that
* created the #XbSilo.
*
* Please note: Only a subset of XPath is supported.
* @param query an #XbQuery
* @param context context including values bound to opcodes of type %XB_OPCODE_KIND_BOUND_INTEGER or %XB_OPCODE_KIND_BOUND_TEXT, or %NULL if the query doesn’t need any context
* @returns results, or %NULL if unfound
*/
query_with_context(query: Query, context?: QueryContext | null): Node[];
/**
* Saves a silo to a file.
* @param file a #GFile
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE for success, otherwise @error is set.
*/
save_to_file(file: Gio.File, cancellable?: Gio.Cancellable | null): boolean;
/**
* Set #XbSilo:enable-node-cache.
*
* This is not thread-safe, and can only be called before the #XbSilo is passed
* between threads.
* @param enable_node_cache %TRUE to enable the node cache, %FALSE otherwise
*/
set_enable_node_cache(enable_node_cache: boolean): void;
/**
* Enables or disables the collection of profiling data.
* @param profile_flags some #XbSiloProfileFlags, e.g. %XB_SILO_PROFILE_FLAG_DEBUG
*/
set_profile_flags(profile_flags: SiloProfileFlags | null): void;
/**
* Converts the silo to an internal string representation. This is only
* really useful for debugging #XbSilo itself.
* @returns A string, or %NULL for an error
*/
to_string(): string;
/**
* Adds a file monitor to the silo. If the file or directory for `file` changes
* then the silo will be invalidated.
*
* The monitor will internally use the #GMainContext which was the thread
* default when the #XbSilo was created, so that #GMainContext must be iterated
* for monitoring to work.
* @param file a #GFile
* @param cancellable a #GCancellable, or %NULL
* @returns %TRUE for success, otherwise @error is set.
*/
watch_file(file: Gio.File, cancellable?: Gio.Cancellable | null): boolean;
}
type BuilderClass = typeof Builder;
type BuilderFixupClass = typeof BuilderFixup;
type BuilderNodeClass = typeof BuilderNode;
type BuilderSourceClass = typeof BuilderSource;
type BuilderSourceCtxClass = typeof BuilderSourceCtx;
type MachineClass = typeof Machine;
/**
* A #XbNodeAttrIter structure represents an iterator that can be used
* to iterate over the attributes of a #XbNode. #XbNodeAttrIter
* structures are typically allocated on the stack and then initialized
* with xb_node_attr_iter_init().
*
* The iteration order of a #XbNodeAttrIter is not defined.
*/
class NodeAttrIter {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial<{}>);
_init(...args: any[]): void;
// Methods
/**
* Initializes a name/value pair iterator for the node attributes
* and associates it with `self`.
* The #XbNodeAttrIter structure is typically allocated on the stack
* and does not need to be freed explicitly.
* @param self a #XbNode
*/
init(self: Node): void;
/**
* Returns the current attribute name and value and advances the iterator.
* Example:
*
* ```c
* XbNodeAttrIter iter;
* const gchar *attr_name, *attr_value;
*
* xb_node_attr_iter_init (&iter, node);
* while (xb_node_attr_iter_next (&iter, &attr_name, &attr_value)) {
* // use attr_name and attr_value; no need to free them
* }
* ```
*
* @returns %TRUE if there are more attributes.
*/
next(): [boolean, string, string];
}
/**
* A #XbNodeChildIter structure represents an iterator that can be used
* to iterate over the children of a #XbNode. #XbNodeChildIter
* structures are typically allocated on the stack and then initialized
* with xb_node_child_iter_init().
*/
class NodeChildIter {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial<{}>);
_init(...args: any[]): void;
// Methods
/**
* Initializes a child iterator for the node's children and associates
* it with `self`.
* The #XbNodeChildIter structure is typically allocated on the stack
* and does not need to be freed explicitly.
* @param self a #XbNode
*/
init(self: Node): void;
/**
* Returns the current child and advances the iterator.
* The retrieved #XbNode child needs to be dereferenced with g_object_unref().
* Example:
*
* ```c
* XbNodeChildIter iter;
* g_autoptr(XbNode) child = NULL;
*
* xb_node_child_iter_init (&iter, node);
* while (xb_node_child_iter_next (&iter, &child)) {
* // do something with the node child
* g_clear_pointer (&child, g_object_unref);
* }
* ```
*
* @returns %FALSE if the last child has been reached.
*/
next(): [boolean, Node | null];
}
type NodeClass = typeof Node;
abstract class Opcode {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
// Static methods
/**
* Converts a string to an opcode kind.
* @param str a string, e.g. `FUNC`
*/
static kind_from_string(str: string): OpcodeKind;
/**
* Converts the opcode kind to a string.
* @param kind a #XbOpcodeKind, e.g. %XB_OPCODE_KIND_FUNCTION
*/
static kind_to_string(kind: OpcodeKind): string;
// Methods
/**
* Checks if the opcode can be compared using the string value.
* @returns #%TRUE if this opcode can be compared as an string
*/
cmp_str(): boolean;
/**
* Checks if the opcode can be compared using the integer value.
* @returns #%TRUE if this opcode can be compared as an integer
*/
cmp_val(): boolean;
/**
* Initialises a stack allocated #XbOpcode to contain a specific function.
* Custom functions can be registered using xb_machine_add_func() and retrieved
* using xb_machine_opcode_func_new().
* @param func a function index
*/
func_init(func: number): void;
/**
* Gets the opcode kind.
* @returns a #XbOpcodeKind, e.g. %XB_OPCODE_KIND_INTEGER
*/
get_kind(): OpcodeKind;
/**
* Gets the string value stored on the opcode.
* @returns a string, or %NULL if unset
*/
get_str(): string;
/**
* Gets the integer value stored in the opcode. This may be a function ID,
* a index into the string table or a literal integer.
* @returns value, or 0 for unset.
*/
get_val(): number;
/**
* Initialises a stack allocated #XbOpcode to contain an integer literal.
* @param val a integer value
*/
integer_init(val: number): void;
/**
* Initialises a stack allocated #XbOpcode to contain a text literal.
* The `str` argument is copied internally and is not tied to the lifecycle of
* the #XbOpcode.
* @param str a string
*/
text_init(str: string): void;
/**
* Initialises a stack allocated #XbOpcode to contain a text literal, where
* `str` is either static text or will outlive the #XbOpcode lifecycle.
* @param str a string
*/
text_init_static(str: string): void;
/**
* Initialises a stack allocated #XbOpcode to contain a text literal, stealing
* the `str`. Once the opcode is finalized g_free() will be called on `str`.
* @param str a string
*/
text_init_steal(str: string): void;
/**
* Returns a string representing the specific opcode.
* @returns text
*/
to_string(): string;
}
type QueryClass = typeof Query;
/**
* An opaque struct which contains context for executing a query in, such as the
* number of results to return, or values to bind to query placeholders.
*/
class QueryContext {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial<{}>);
_init(...args: any[]): void;
// Methods
/**
* Clear an #XbQueryContext, freeing any allocated memory it points to.
*
* After this function has been called, the contents of the #XbQueryContext are
* undefined, and it’s only safe to call xb_query_context_init() on it.
*/
clear(): void;
/**
* Copy `self` into a new heap-allocated #XbQueryContext instance.
* @returns a copy of @self
*/
copy(): QueryContext;
/**
* Free a heap-allocated #XbQueryContext instance. This should be used on
* #XbQueryContext instances created with xb_query_context_copy().
*
* For stack-allocated instances, xb_query_context_clear() should be used
* instead.
*/
free(): void;
/**
* Get the #XbValueBindings for this query context.
* @returns bindings
*/
get_bindings(): ValueBindings;
/**
* Get the flags set on the context. See xb_query_context_set_flags().
* @returns query flags
*/
get_flags(): QueryFlags;
/**
* Get the limit on the number of query results. See
* xb_query_context_set_limit().
* @returns limit on results, or `0` if unlimited
*/
get_limit(): number;
/**
* Initialise a stack-allocated #XbQueryContext struct so it can be used.
*
* Stack-allocated #XbQueryContext instances should be freed once finished
* with, using xb_query_context_clear() (or `g_auto(XbQueryContext)`, which is
* equivalent).
*/
init(): void;
/**
* Set flags which affect the behaviour of the query.
* @param flags query flags, or %XB_QUERY_FLAG_NONE for none
*/
set_flags(flags: QueryFlags | null): void;
/**
* Set the limit on the number of results to return from the query.
* @param limit number of query results to return, or `0` for unlimited
*/
set_limit(limit: number): void;
}
type SiloClass = typeof Silo;
abstract class Stack {
static $gtype: GObject.GType;
// Constructors
_init(...args: any[]): void;
// Methods
/**
* Pops an opcode off the stack.
* @returns %TRUE if popping succeeded, %FALSE if the stack was empty already
*/
pop(): [boolean, Opcode | null];
/**
* Pushes a new empty opcode onto the end of the stack. A pointer to the opcode
* is returned in `opcode_out` so that the caller can initialise it. This must be
* done before the stack is next used as, for performance reasons, the newly
* pushed opcode is not zero-initialised.
* @returns %TRUE if a new empty opcode was returned, or %FALSE if the stack has reached its maximum size
*/
push(): [boolean, Opcode | null];
/**
* Returns a string representing a stack.
* @returns text
*/
to_string(): string;
}
/**
* An opaque struct which contains values bound to a query.
*/
class ValueBindings {
static $gtype: GObject.GType;
// Constructors
constructor(properties?: Partial<{}>);
_init(...args: any[]): void;
// Methods
/**
* Bind `str` to `idx` in the value bindings.
*
* This will overwrite any previous binding at `idx`. It will take ownership of
* `str,` and an appropriate `destroy_func` must be provided to free `str` once the
* binding is no longer needed. `destroy_func` will be called exactly once at
* some point before the #XbValueBindings is cleared or freed.
* @param idx 0-based index to bind to
* @param str a string to bind to @idx
* @param destroy_func function to free @str
*/
bind_str(idx: number, str: string, destroy_func?: GLib.DestroyNotify | null): void;
/**
* Bind `val` to `idx` in the value bindings.
*
* This will overwrite any previous binding at `idx`.
* @param idx 0-based index to bind to
* @param val an integer to bind to @idx
*/
bind_val(idx: number, val: number): void;
/**
* Clear an #XbValueBindings, freeing any allocated memory it points to.
*
* After this function has been called, the contents of the #XbValueBindings are
* undefined, and it’s only safe to call xb_value_bindings_init() on it.
*/
clear(): void;
/**
* Copy `self` into a new heap-allocated #XbValueBindings instance.
* @returns a copy of @self
*/
copy(): ValueBindings;
/**
* Copies the value bound at `idx` on `self` to `dest_idx` on `dest`. If no value is
* bound at `idx,` `dest` is not modified and %FALSE is returned.
*
* `dest` must be initialised. If a binding already exists at `dest_idx,` it will
* be overwritten.
* @param idx 0-based index to look up the binding from in @self
* @param dest an #XbValueBindings to copy to
* @param dest_idx 0-based index to copy the binding to in @dest
* @returns %TRUE if @idx was bound, %FALSE otherwise
*/
copy_binding(idx: number, dest: ValueBindings, dest_idx: number): boolean;
/**
* Free a heap-allocated #XbValueBindings instance. This should be used on
* #XbValueBindings instances created with xb_value_bindings_copy().
*
* For stack-allocated instances, xb_value_bindings_clear() should be used
* instead.
*/
free(): void;
/**
* Initialise a stack-allocated #XbValueBindings struct so it can be used.
*
* Stack-allocated #XbValueBindings instances should be freed once finished
* with, using xb_value_bindings_clear() (or `g_auto(XbValueBindings)`, which is
* equivalent).
*/
init(): void;
/**
* Check whether a value has been bound to the given index using (for example)
* xb_value_bindings_bind_str().
* @param idx 0-based index of the binding to check
* @returns %TRUE if a value is bound to @idx, %FALSE otherwise
*/
is_bound(idx: number): boolean;
/**
* Initialises an #XbOpcode with the value bound to `idx,` if a value is bound.
* If no value is bound, `opcode_out` is not touched and %FALSE is returned.
*
* `opcode_out` is initialised to point to the data inside the #XbValueBindings,
* so must have a shorter lifetime than the #XbValueBindings. It will be of kind
* %XB_OPCODE_KIND_BOUND_TEXT or %XB_OPCODE_KIND_BOUND_INTEGER.
* @param idx 0-based index to look up the binding from
* @returns %TRUE if @idx was bound, %FALSE otherwise
*/
lookup_opcode(idx: number): [boolean, Opcode];
}
/**
* Name of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
*/
const __name__: string;
/**
* Version of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
*/
const __version__: string;
}
export default Xmlb;
}
declare module 'gi://Xmlb' {
import Xmlb20 from 'gi://Xmlb?version=2.0';
export default Xmlb20;
}
// END