glib
MoonBit bindings for GLib non-GObject types (GError, GMainLoop, GVariant, etc.)
glib
ffi
native
gtk
moon add tonyfettes/glib@0.2.0
Download zipAuthor
Version
0.2.0
License
Apache-2.0
Last updated
23 days ago
Downloads
255
README#GLib Bindings for MoonBit
This package provides MoonBit bindings for the GLib C library, offering
error handling and event loop functionality. All types are GC-managed —
no manual free() or unref() needed.
#Features
- Error Handling: Error_ with domain, code, and message
- Event Loop: MainLoop and MainContext
#Requirements
The GLib library (libglib-2.0.so) must be installed on your system.
#Usage
#Error Handling with Error_
///|
test {
let error = @glib.Error_::new(1U, 42, "Operation failed")
assert_eq(error.domain(), 1U)
assert_eq(error.code(), 42)
assert_true(error.message().contains("Operation failed"))
assert_true(error.matches(1U, 42))
assert_false(error.matches(1U, 99))
let copy = error.copy()
assert_eq(copy.code(), error.code())
// No need to free — GC handles cleanup
}#Main Event Loop
///|
test {
let ctx = @glib.MainContext::new()
let main_loop = @glib.MainLoop::new(ctx, false)
assert_false(main_loop.is_running())
assert_false(ctx.pending())
let dispatched = ctx.iteration(false)
assert_false(dispatched)
// No need to unref — GC handles cleanup
}#Using Default Context
///|
test {
let main_loop = @glib.MainLoop::new_default(false)
let ctx = main_loop.get_context()
let _ = ctx
}#API Reference
#Error_ Methods
| Method | Description |
|---|---|
| Error_::new(domain, code, message) | Create new error |
| error.copy() | Deep copy error |
| error.matches(domain, code) | Check if error matches |
| error.message() | Get error message |
| error.code() | Get error code |
| error.domain() | Get error domain |
#MainContext Methods
| Method | Description |
|---|---|
| MainContext::new() | Create new context |
| MainContext::default() | Get global default context |
| ctx.iteration(may_block) | Run one iteration |
| ctx.pending() | Check for pending events |
| ctx.wakeup() | Wake up blocked context |
#MainLoop Methods
| Method | Description |
|---|---|
| MainLoop::new(ctx, is_running) | Create with context |
| MainLoop::new_default(is_running) | Create with default context |
| loop.run() | Run until quit |
| loop.quit() | Signal loop to quit |
| loop.is_running() | Check if running |
| loop.get_context() | Get loop's context |
#IUri
pub(open) trait IUri {
fn as_uri(Self) -> Uri
fn get_auth_params(Self) -> String? = _
fn get_flags(Self) -> UriFlags = _
fn get_fragment(Self) -> String? = _
fn get_host(Self) -> String? = _
fn get_password(Self) -> String? = _
fn get_path(Self) -> String = _
fn get_port(Self) -> Int = _
fn get_query(Self) -> String? = _
fn get_scheme(Self) -> String = _
fn get_user(Self) -> String? = _
fn get_userinfo(Self) -> String? = _
fn parse_relative(Self, String, UriFlags) -> Uri raise Error_ = _
fn to_string(Self) -> String = _
fn to_string_partial(Self, UriHideFlags) -> String = _
}#Error_
pub suberror Error_Error_ - GLib's error structure.
Automatically freed when garbage collected.
#Error_::matches
Check if error matches the specified domain and code.
Example
test {
let error = @glib.Error_::new(5U, 100, "Network error")
assert_true(error.matches(5U, 100))
assert_false(error.matches(5U, 101))
assert_false(error.matches(6U, 100))
}#Error_::new
Create a new Error_.
Example
test {
let error = @glib.Error_::new(1U, 42, "Something went wrong")
assert_eq(error.code(), 42)
assert_eq(error.domain(), 1U)
assert_true(error.message().contains("Something went wrong"))
}#HashTable
#external
pub type HashTable#HashTable::insert_str_str
Insert a string key/value (both copied into the table).
#HashTable::iter
Open an iterator positioned before the first entry.
#HashTable::new_str
Build an empty owned GHashTable<utf8,utf8> (string hash/equal, frees both
key and value). For the parameter direction.
#HashTableIter
pub type HashTableIterGC-managed iterator over a HashTable's entries. Reclaimed automatically;
the underlying table must outlive it (it always does within a wrapper).
#HashTableIter::key_bytes
Current entry's key as the raw bytes of a C string (utf8/filename keys).
#HashTableIter::key_int
Current entry's key as an int (primitive / enum / bool keys).
#HashTableIter::next
Advance to the next entry; returns false once the entries are exhausted.
#HashTableIter::val_bytes
Current entry's value as the raw bytes of a C string.
#HashTableIter::val_int
Current entry's value as an int.
#IOCondition
pub struct IOCondition {
// private fields
}#IOCondition::IOCondition
#IOConditionFlag
pub(all) enum IOConditionFlag {
In
Out
Pri
Err
Hup
Nval
}#MainContext
pub type MainContextMainContext - event source context.
Automatically unreffed when garbage collected.
#MainContext::default
Get the global default MainContext.
#MainContext::iteration
Run a single iteration. Returns true if events were dispatched.
#MainContext::new
Create a new MainContext.
Example
test {
let ctx = @glib.MainContext::new()
assert_false(ctx.pending())
}#MainContext::pending
Check if there are pending events.
#MainContext::wakeup
Wake up the context if blocked in a poll.
#MainLoop
pub type MainLoopMainLoop - main event loop.
Automatically unreffed when garbage collected.
#MainLoop::get_context
Get the context of the main loop.
#MainLoop::is_running
Check if the main loop is running.
#MainLoop::new
Create a new MainLoop with the given context.
Example
test {
let ctx = @glib.MainContext::new()
let main_loop = @glib.MainLoop::new(ctx, false)
assert_false(main_loop.is_running())
}#MainLoop::new_default
Create a new MainLoop with the default context.
Example
test {
let main_loop = @glib.MainLoop::new_default(false)
assert_false(main_loop.is_running())
}#Mutex
pub type MutexAn owned GLib mutex.
The mutex is initialized on construction and cleared when its MoonBit
wrapper is collected. It is non-recursive, matching GMutex.
#Mutex::try_lock
Attempts to acquire this mutex without blocking.
#Nullable
type Nullable[T]#Uri
pub type Uri
#Uri::build
#Uri::build_with_user
#Uri::escape_string
fn Uri::escape_string(unescaped : String, reserved_chars_allowed : String?, allow_utf8 : Bool) -> String#Uri::is_valid
#Uri::join
#Uri::join_with_user
#Uri::parse
#Uri::parse_params
fn Uri::parse_params(params : String, length : Int64, separators : String, flags : UriParamsFlags) -> Map[String, String] raise Error_#Uri::parse_relative
#Uri::resolve_relative
#Uri::split
#Uri::split_network
#Uri::split_with_user
#Uri::to_string_partial
#Uri::unescape_bytes
#Uri::unescape_segment
fn Uri::unescape_segment(escaped_string : String?, escaped_string_end : String?, illegal_characters : String?) -> String?#Uri::unescape_string
#UriFlag
pub(all) enum UriFlag {
None
ParseRelaxed
HasPassword
HasAuthParams
Encoded
NonDns
EncodedQuery
EncodedPath
EncodedFragment
SchemeNormalize
}#UriFlags
pub struct UriFlags {
// private fields
}#UriHideFlag
pub(all) enum UriHideFlag {
None
Userinfo
Password
AuthParams
Query
Fragment
}#UriHideFlags
pub struct UriHideFlags {
// private fields
}#UriHideFlags::UriHideFlags
#UriParamsFlag
pub(all) enum UriParamsFlag {
None
CaseInsensitive
WwwForm
ParseRelaxed
}#UriParamsFlags
pub struct UriParamsFlags {
// private fields
}#UriParamsFlags::UriParamsFlags
#Variant
pub type Variant#Variant::as_bool
Get the boolean value, or None if the variant is not of type "b".
#Variant::as_double
Get the double value, or None if not of type "d".
#Variant::as_int32
Get the 32-bit signed integer value, or None if not of type "i".
#Variant::as_int64
Get the 64-bit signed integer value, or None if not of type "x".
#Variant::as_string
Get the string value, or None if not of type "s".
#Variant::as_uint32
Get the 32-bit unsigned integer value, or None if not of type "u".
#Variant::as_uint64
Get the 64-bit unsigned integer value, or None if not of type "t".
#Variant::from_bool
Create a Variant holding a boolean value.
test {
let v = @glib.Variant::from_bool(true)
@debug.assert_eq(v.type_string(), "b")
@debug.assert_eq(v.as_bool(), Some(true))
}#Variant::from_double
Create a Variant holding a double-precision float.
#Variant::from_int32
Create a Variant holding a 32-bit signed integer.
test {
let v = @glib.Variant::from_int32(42)
@debug.assert_eq(v.type_string(), "i")
@debug.assert_eq(v.as_int32(), Some(42))
}#Variant::from_int64
Create a Variant holding a 64-bit signed integer.
#Variant::from_string
Create a Variant holding a string.
test {
let v = @glib.Variant::from_string("hello")
@debug.assert_eq(v.type_string(), "s")
@debug.assert_eq(v.as_string(), Some("hello"))
}#Variant::from_uint32
Create a Variant holding a 32-bit unsigned integer.
#Variant::from_uint64
Create a Variant holding a 64-bit unsigned integer.
#Variant::is_of_type
Check if this variant is of the given type.
#UNICHAR_MAX_DECOMPOSITION_LENGTH
let UNICHAR_MAX_DECOMPOSITION_LENGTH : Int#idle_add
fn idle_add(callback : () -> Bool) -> UIntSchedule a callback to run when the main loop is idle.
The callback returns true to be called again, false to be removed.
#source_remove
fn source_remove(tag : UInt) -> BoolRemove a source from the main loop by its ID (as returned by timeout_add or idle_add).
Returns true if the source was found and removed.
#test_get_hash_table
Copy a C-owned table into a Map (return direction), then release it.
#test_roundtrip_hash_table
Build a table from a Map (parameter direction), hand it to C, release it.
#timeout_add
fn timeout_add(interval : UInt, callback : () -> Bool) -> UIntSchedule a callback to run repeatedly at the given interval (in milliseconds).
The callback returns true to continue, false to stop.
#utf8_collate
fn utf8_collate(left : String, right : String) -> IntCompares two UTF-8 strings using the current locale's collation rules.
MoonBit bindings for GLib non-GObject types (GError, GMainLoop, GVariant, etc.)
glibffinativegtk
0.2.0
Apache-2.0
Updated 23 days ago
255 downloads