🥮 mooncakes.io

    sysinfo

    System metrics and process inspection library.

    sysinfo
    metrics
    Download zip
    Author
    Version
    0.1.4
    License
    Apache-2.0
    Repository
    Last updated
    48 minutes ago
    Downloads
    729

    Dependencies

    #Milky2018/sysinfo

    A MoonBit-native system metrics and process inspection library for Linux and macOS.

    #Status

    • native target only.
    • Linux: fully supported.
    • macOS: fully supported.
    • Other OSes: unsupported semantics (is_supported_system == false, APIs return None, empty collections, or no-op defaults instead of panicking).

    #Install

    moon add Milky2018/sysinfo

    #Quick Start

    let system = @sysinfo.System::new_all()

    println("supported=\{@sysinfo.is_supported_system}")
    println("total_memory=\{system.total_memory()}")
    println("used_memory=\{system.used_memory()}")
    println("cpu_usage=\{system.global_cpu_usage()}")
    println("process_count=\{system.processes().size()}")

    #Refresh Semantics

    sysinfo-style delta metrics require at least two refreshes with an interval:

    • CPU usage
    • Network traffic deltas
    • Process CPU usage

    MINIMUM_CPU_UPDATE_INTERVAL is fixed to 200 ms.

    let system = @sysinfo.System::new_all()
    system.refresh_cpu_usage()

    sleep(220)

    system.refresh_cpu_usage()
    let usage = system.global_cpu_usage()

    #Main API Surface

    • System: System, RefreshKind, CpuRefreshKind, MemoryRefreshKind, ProcessRefreshKind
    • Process: Process, Pid, Uid, Gid, ProcessStatus, ThreadKind, Signal, KillError
    • CPU: Cpu
    • Disks: Disks, Disk, DiskKind, DiskRefreshKind, DiskUsage
    • Networks: Networks, NetworkData, MacAddr, IpNetwork
    • Components: Components, Component
    • Users/Groups: Users, User, Groups, Group
    • Globals: is_supported_system, MINIMUM_CPU_UPDATE_INTERVAL, supported_signals

    #Process Control

    Supported process-control APIs:

    • Process::kill()
    • Process::kill_with(signal)
    • Process::wait()
    • Process::kill_and_wait()
    • Process::kill_with_and_wait(signal)

    On unsupported systems, these return unsupported-safe values (None/Err(KillError::Unsupported)), matching the library's non-panicking downgrade policy.

    #Notes

    • set_open_files_limit and System::open_files_limit follow upstream behavior:
      • Linux: implemented.
      • macOS: set returns false; query may return a system limit when available.
    • supported_signals exposes the signal list supported by this binding.

    CGroupLimits

    source
    pub(all) struct CGroupLimits {
      total_memory : UInt64
      free_memory : UInt64
      free_swap : UInt64
    } derive(Eq, 
    Debug    )

    CGroupLimits::equal

    source

    CGroupLimits::not_equal

    source
    fn CGroupLimits::not_equal(x : CGroupLimits, y : CGroupLimits) -> Bool

    CGroupLimits::output

    source
    fn CGroupLimits::output(self : CGroupLimits, logger : &Logger) -> Unit

    CGroupLimits::to_repr

    source

    CGroupLimits::to_string

    source
    fn CGroupLimits::to_string(self : CGroupLimits) -> String

    Component

    source
    pub(all) struct Component {
      temperature : Double?
      max : Double?
      critical : Double?
      label : String
      id : String?
    } derive(Eq, 
    Debug    )

    impl Show for Component

    Component::critical

    source
    fn Component::critical(self : Component) -> Double?

    Component::equal

    source
    fn Component::equal(Component, Component) -> Bool

    Component::id

    source
    fn Component::id(self : Component) -> String?

    Component::label

    source
    fn Component::label(self : Component) -> String

    Component::max

    source
    fn Component::max(self : Component) -> Double?

    Component::not_equal

    source
    fn Component::not_equal(x : Component, y : Component) -> Bool

    Component::output

    source
    fn Component::output(self : Component, logger : &Logger) -> Unit

    Component::refresh

    source
    fn Component::refresh(self : Component) -> Unit

    Component::temperature

    source
    fn Component::temperature(self : Component) -> Double?

    Component::to_repr

    source

    Component::to_string

    source
    fn Component::to_string(self : Component) -> String

    Components

    source
    pub(all) struct Components {
      components_data : Array[Component]
    } derive(
    Debug    )

    impl Show for Components

    Components::list

    source
    fn Components::list(self : Components) -> Array[Component]

    Components::list_mut

    source
    fn Components::list_mut(self : Components) -> Array[Component]

    Components::new

    source
    fn Components::new() -> Components

    Components::new_with_refreshed_list

    source
    fn Components::new_with_refreshed_list() -> Components

    Components::output

    source
    fn Components::output(self : Components, logger : &Logger) -> Unit

    Components::refresh

    source
    fn Components::refresh(self : Components, remove_not_listed_components : Bool) -> Unit

    Components::to_repr

    source

    Components::to_string

    source
    fn Components::to_string(self : Components) -> String

    Cpu

    source
    pub(all) struct Cpu {
      name : String
      vendor_id : String
      brand : String
      frequency : UInt64
      cpu_usage : Double
    } derive(Eq, 
    Debug    )

    impl Show for Cpu

    Cpu::brand

    source
    fn Cpu::brand(self : Cpu) -> String

    Cpu::cpu_usage

    source
    fn Cpu::cpu_usage(self : Cpu) -> Double

    Cpu::equal

    source
    fn Cpu::equal(Cpu, Cpu) -> Bool

    Cpu::frequency

    source
    fn Cpu::frequency(self : Cpu) -> UInt64

    Cpu::name

    source
    fn Cpu::name(self : Cpu) -> String

    Cpu::not_equal

    source
    fn Cpu::not_equal(x : Cpu, y : Cpu) -> Bool

    Cpu::output

    source
    fn Cpu::output(self : Cpu, logger : &Logger) -> Unit

    Cpu::to_repr

    source

    Cpu::to_string

    source
    fn Cpu::to_string(self : Cpu) -> String

    Cpu::vendor_id

    source
    fn Cpu::vendor_id(self : Cpu) -> String

    CpuRefreshKind

    source
    pub(all) struct CpuRefreshKind {
      cpu_usage : Bool
      frequency : Bool
    } derive(Eq, 
    Debug    )

    CpuRefreshKind::cpu_usage

    source
    fn CpuRefreshKind::cpu_usage(self : CpuRefreshKind) -> Bool

    CpuRefreshKind::equal

    source

    CpuRefreshKind::everything

    source
    fn CpuRefreshKind::everything() -> CpuRefreshKind

    CpuRefreshKind::frequency

    source
    fn CpuRefreshKind::frequency(self : CpuRefreshKind) -> Bool

    CpuRefreshKind::not_equal

    source
    fn CpuRefreshKind::not_equal(x : CpuRefreshKind, y : CpuRefreshKind) -> Bool

    CpuRefreshKind::nothing

    source

    CpuRefreshKind::output

    source
    fn CpuRefreshKind::output(self : CpuRefreshKind, logger : &Logger) -> Unit

    CpuRefreshKind::to_repr

    source

    CpuRefreshKind::to_string

    source
    fn CpuRefreshKind::to_string(self : CpuRefreshKind) -> String

    CpuRefreshKind::with_cpu_usage

    source
    fn CpuRefreshKind::with_cpu_usage(self : CpuRefreshKind) -> CpuRefreshKind

    CpuRefreshKind::with_frequency

    source
    fn CpuRefreshKind::with_frequency(self : CpuRefreshKind) -> CpuRefreshKind

    CpuRefreshKind::without_cpu_usage

    source
    fn CpuRefreshKind::without_cpu_usage(self : CpuRefreshKind) -> CpuRefreshKind

    CpuRefreshKind::without_frequency

    source
    fn CpuRefreshKind::without_frequency(self : CpuRefreshKind) -> CpuRefreshKind

    CpuSnapshot

    source
    type CpuSnapshot derive(Eq, 
    Debug    )

    impl Show for CpuSnapshot

    CpuSnapshot::equal

    source
    fn CpuSnapshot::equal(CpuSnapshot, CpuSnapshot) -> Bool

    CpuSnapshot::not_equal

    source
    fn CpuSnapshot::not_equal(x : CpuSnapshot, y : CpuSnapshot) -> Bool

    CpuSnapshot::output

    source
    fn CpuSnapshot::output(self : CpuSnapshot, logger : &Logger) -> Unit

    CpuSnapshot::to_repr

    source

    CpuSnapshot::to_string

    source
    fn CpuSnapshot::to_string(self : CpuSnapshot) -> String

    Disk

    source
    pub(all) struct Disk {
      kind : DiskKind
      name : String
      file_system : String
      mount_point : String
      total_space : UInt64
      available_space : UInt64
      is_removable : Bool
      is_read_only : Bool
      usage : DiskUsage
    } derive(Eq, 
    Debug    )

    impl Show for Disk

    Disk::available_space

    source
    fn Disk::available_space(self : Disk) -> UInt64

    Disk::equal

    source
    fn Disk::equal(Disk, Disk) -> Bool

    Disk::file_system

    source
    fn Disk::file_system(self : Disk) -> String

    Disk::is_read_only

    source
    fn Disk::is_read_only(self : Disk) -> Bool

    Disk::is_removable

    source
    fn Disk::is_removable(self : Disk) -> Bool

    Disk::kind

    source
    fn Disk::kind(self : Disk) -> DiskKind

    Disk::mount_point

    source
    fn Disk::mount_point(self : Disk) -> String

    Disk::name

    source
    fn Disk::name(self : Disk) -> String

    Disk::not_equal

    source
    fn Disk::not_equal(x : Disk, y : Disk) -> Bool

    Disk::output

    source
    fn Disk::output(self : Disk, logger : &Logger) -> Unit

    Disk::refresh

    source
    fn Disk::refresh(self : Disk) -> Bool

    Disk::refresh_specifics

    source
    fn Disk::refresh_specifics(self : Disk, refreshes : DiskRefreshKind) -> Bool

    Disk::to_repr

    source

    Disk::to_string

    source
    fn Disk::to_string(self : Disk) -> String

    Disk::total_space

    source
    fn Disk::total_space(self : Disk) -> UInt64

    Disk::usage

    source
    fn Disk::usage(self : Disk) -> DiskUsage

    DiskIoSnapshot

    source
    type DiskIoSnapshot derive(Eq, 
    Debug    )

    DiskIoSnapshot::equal

    source

    DiskIoSnapshot::not_equal

    source
    fn DiskIoSnapshot::not_equal(x : DiskIoSnapshot, y : DiskIoSnapshot) -> Bool

    DiskIoSnapshot::output

    source
    fn DiskIoSnapshot::output(self : DiskIoSnapshot, logger : &Logger) -> Unit

    DiskIoSnapshot::to_repr

    source

    DiskIoSnapshot::to_string

    source
    fn DiskIoSnapshot::to_string(self : DiskIoSnapshot) -> String

    DiskKind

    source
    pub(all) enum DiskKind {
      HDD
      SSD
      Unknown(String)
    } derive(Eq, 
    Debug    )

    impl Show for DiskKind

    DiskKind::equal

    source
    fn DiskKind::equal(DiskKind, DiskKind) -> Bool

    DiskKind::not_equal

    source
    fn DiskKind::not_equal(x : DiskKind, y : DiskKind) -> Bool

    DiskKind::output

    source
    fn DiskKind::output(self : DiskKind, logger : &Logger) -> Unit

    DiskKind::to_repr

    source

    DiskKind::to_string

    source
    fn DiskKind::to_string(self : DiskKind) -> String

    DiskRefreshKind

    source
    pub(all) struct DiskRefreshKind {
      kind : Bool
      storage : Bool
      io_usage : Bool
    } derive(Eq, 
    Debug    )

    DiskRefreshKind::equal

    source

    DiskRefreshKind::everything

    source
    fn DiskRefreshKind::everything() -> DiskRefreshKind

    DiskRefreshKind::io_usage

    source
    fn DiskRefreshKind::io_usage(self : DiskRefreshKind) -> Bool

    DiskRefreshKind::kind

    source
    fn DiskRefreshKind::kind(self : DiskRefreshKind) -> Bool

    DiskRefreshKind::not_equal

    source
    fn DiskRefreshKind::not_equal(x : DiskRefreshKind, y : DiskRefreshKind) -> Bool

    DiskRefreshKind::nothing

    source

    DiskRefreshKind::output

    source
    fn DiskRefreshKind::output(self : DiskRefreshKind, logger : &Logger) -> Unit

    DiskRefreshKind::storage

    source
    fn DiskRefreshKind::storage(self : DiskRefreshKind) -> Bool

    DiskRefreshKind::to_repr

    source

    DiskRefreshKind::to_string

    source
    fn DiskRefreshKind::to_string(self : DiskRefreshKind) -> String

    DiskRefreshKind::with_io_usage

    source
    fn DiskRefreshKind::with_io_usage(self : DiskRefreshKind) -> DiskRefreshKind

    DiskRefreshKind::with_kind

    source

    DiskRefreshKind::with_storage

    source
    fn DiskRefreshKind::with_storage(self : DiskRefreshKind) -> DiskRefreshKind

    DiskRefreshKind::without_io_usage

    source
    fn DiskRefreshKind::without_io_usage(self : DiskRefreshKind) -> DiskRefreshKind

    DiskRefreshKind::without_kind

    source
    fn DiskRefreshKind::without_kind(self : DiskRefreshKind) -> DiskRefreshKind

    DiskRefreshKind::without_storage

    source
    fn DiskRefreshKind::without_storage(self : DiskRefreshKind) -> DiskRefreshKind

    DiskUsage

    source
    pub(all) struct DiskUsage {
      total_read_bytes : UInt64
      read_bytes : UInt64
      total_written_bytes : UInt64
      written_bytes : UInt64
    } derive(Eq, 
    Debug    )

    impl Show for DiskUsage

    DiskUsage::equal

    source
    fn DiskUsage::equal(DiskUsage, DiskUsage) -> Bool

    DiskUsage::not_equal

    source
    fn DiskUsage::not_equal(x : DiskUsage, y : DiskUsage) -> Bool

    DiskUsage::output

    source
    fn DiskUsage::output(self : DiskUsage, logger : &Logger) -> Unit

    DiskUsage::to_repr

    source

    DiskUsage::to_string

    source
    fn DiskUsage::to_string(self : DiskUsage) -> String

    DiskUsage::zero

    source
    fn DiskUsage::zero() -> DiskUsage

    Disks

    source
    pub(all) struct Disks {
      disks_data : Array[Disk]
    } derive(
    Debug    )

    impl Show for Disks

    Disks::list

    source
    fn Disks::list(self : Disks) -> Array[Disk]

    Disks::list_mut

    source
    fn Disks::list_mut(self : Disks) -> Array[Disk]

    Disks::new

    source
    fn Disks::new() -> Disks

    Disks::new_with_refreshed_list

    source
    fn Disks::new_with_refreshed_list() -> Disks

    Disks::new_with_refreshed_list_specifics

    source
    fn Disks::new_with_refreshed_list_specifics(refreshes : DiskRefreshKind) -> Disks

    Disks::output

    source
    fn Disks::output(self : Disks, logger : &Logger) -> Unit

    Disks::refresh

    source
    fn Disks::refresh(self : Disks, remove_not_listed_disks : Bool) -> Unit

    Disks::refresh_specifics

    source
    fn Disks::refresh_specifics(self : Disks, remove_not_listed_disks : Bool, refreshes : DiskRefreshKind) -> Unit

    Disks::to_repr

    source

    Disks::to_string

    source
    fn Disks::to_string(self : Disks) -> String

    ExitStatus

    source
    pub(all) struct ExitStatus {
      code : Int?
      signal : Signal?
      success : Bool
    } derive(Eq, 
    Debug    )

    impl Show for ExitStatus

    ExitStatus::equal

    source
    fn ExitStatus::equal(ExitStatus, ExitStatus) -> Bool

    ExitStatus::from_code

    source
    fn ExitStatus::from_code(code : Int) -> ExitStatus

    ExitStatus::from_signal

    source
    fn ExitStatus::from_signal(signal : Signal) -> ExitStatus

    ExitStatus::not_equal

    source
    fn ExitStatus::not_equal(x : ExitStatus, y : ExitStatus) -> Bool

    ExitStatus::output

    source
    fn ExitStatus::output(self : ExitStatus, logger : &Logger) -> Unit

    ExitStatus::to_repr

    source

    ExitStatus::to_string

    source
    fn ExitStatus::to_string(self : ExitStatus) -> String

    Gid

    source
    pub(all) struct Gid {
      value : Int
    } derive(Compare, Eq, Hash, 
    Debug    )

    impl Show for Gid

    Gid::compare

    source
    fn Gid::compare(Gid, Gid) -> Int

    Gid::equal

    source
    fn Gid::equal(Gid, Gid) -> Bool

    Gid::from

    source
    fn Gid::from(value : Int) -> Gid

    Gid::hash

    source
    fn Gid::hash(self : Gid) -> Int

    Gid::hash_combine

    source
    fn Gid::hash_combine(Gid, Hasher) -> Unit

    Gid::not_equal

    source
    fn Gid::not_equal(x : Gid, y : Gid) -> Bool

    Gid::op_ge

    source
    fn Gid::op_ge(x : Gid, y : Gid) -> Bool

    Gid::op_gt

    source
    fn Gid::op_gt(x : Gid, y : Gid) -> Bool

    Gid::op_le

    source
    fn Gid::op_le(x : Gid, y : Gid) -> Bool

    Gid::op_lt

    source
    fn Gid::op_lt(x : Gid, y : Gid) -> Bool

    Gid::output

    source
    fn Gid::output(self : Gid, logger : &Logger) -> Unit

    Gid::to_int

    source
    fn Gid::to_int(self : Gid) -> Int

    Gid::to_repr

    source

    Gid::to_string

    source
    fn Gid::to_string(self : Gid) -> String

    Group

    source
    pub(all) struct Group {
      id : Gid
      name : String
    } derive(Eq, 
    Debug    )

    impl Show for Group

    Group::equal

    source
    fn Group::equal(Group, Group) -> Bool

    Group::id

    source
    fn Group::id(self : Group) -> Gid

    Group::name

    source
    fn Group::name(self : Group) -> String

    Group::not_equal

    source
    fn Group::not_equal(x : Group, y : Group) -> Bool

    Group::output

    source
    fn Group::output(self : Group, logger : &Logger) -> Unit

    Group::to_repr

    source

    Group::to_string

    source
    fn Group::to_string(self : Group) -> String

    Groups

    source
    pub(all) struct Groups {
      groups_data : Array[Group]
    } derive(
    Debug    )

    impl Show for Groups

    Groups::list

    source
    fn Groups::list(self : Groups) -> Array[Group]

    Groups::list_mut

    source
    fn Groups::list_mut(self : Groups) -> Array[Group]

    Groups::new

    source
    fn Groups::new() -> Groups

    Groups::new_with_refreshed_list

    source
    fn Groups::new_with_refreshed_list() -> Groups

    Groups::output

    source
    fn Groups::output(self : Groups, logger : &Logger) -> Unit

    Groups::refresh

    source
    fn Groups::refresh(self : Groups) -> Unit

    Groups::to_repr

    source

    Groups::to_string

    source
    fn Groups::to_string(self : Groups) -> String

    IpNetwork

    source
    pub(all) struct IpNetwork {
      raw : String
    } derive(Eq, 
    Debug    )

    impl Show for IpNetwork

    IpNetwork::equal

    source
    fn IpNetwork::equal(IpNetwork, IpNetwork) -> Bool

    IpNetwork::not_equal

    source
    fn IpNetwork::not_equal(x : IpNetwork, y : IpNetwork) -> Bool

    IpNetwork::output

    source
    fn IpNetwork::output(self : IpNetwork, logger : &Logger) -> Unit

    IpNetwork::to_repr

    source

    IpNetwork::to_string

    source
    fn IpNetwork::to_string(self : IpNetwork) -> String

    KillError

    source
    pub(all) enum KillError {
      Unsupported
      NotFound
      PermissionDenied
      Timeout
      WaitFailed
      Unknown(String)
    } derive(Eq, 
    Debug    )

    impl Show for KillError

    KillError::equal

    source
    fn KillError::equal(KillError, KillError) -> Bool

    KillError::not_equal

    source
    fn KillError::not_equal(x : KillError, y : KillError) -> Bool

    KillError::output

    source
    fn KillError::output(self : KillError, logger : &Logger) -> Unit

    KillError::to_repr

    source

    KillError::to_string

    source
    fn KillError::to_string(self : KillError) -> String

    LoadAvg

    source
    pub(all) struct LoadAvg {
      one : Double
      five : Double
      fifteen : Double
    } derive(Eq, 
    Debug    )

    impl Show for LoadAvg

    LoadAvg::equal

    source
    fn LoadAvg::equal(LoadAvg, LoadAvg) -> Bool

    LoadAvg::not_equal

    source
    fn LoadAvg::not_equal(x : LoadAvg, y : LoadAvg) -> Bool

    LoadAvg::output

    source
    fn LoadAvg::output(self : LoadAvg, logger : &Logger) -> Unit

    LoadAvg::to_repr

    source

    LoadAvg::to_string

    source
    fn LoadAvg::to_string(self : LoadAvg) -> String

    LoadAvg::zero

    source
    fn LoadAvg::zero() -> LoadAvg

    MacAddr

    source
    pub(all) struct MacAddr {
      raw : String
    } derive(Eq, 
    Debug    )

    impl Show for MacAddr

    MacAddr::equal

    source
    fn MacAddr::equal(MacAddr, MacAddr) -> Bool

    MacAddr::is_unspecified

    source
    fn MacAddr::is_unspecified(self : MacAddr) -> Bool

    MacAddr::not_equal

    source
    fn MacAddr::not_equal(x : MacAddr, y : MacAddr) -> Bool

    MacAddr::output

    source
    fn MacAddr::output(self : MacAddr, logger : &Logger) -> Unit

    MacAddr::to_repr

    source

    MacAddr::to_string

    source
    fn MacAddr::to_string(self : MacAddr) -> String

    MacosDiskInfo

    source
    type MacosDiskInfo derive(Eq, 
    Debug    )

    MacosDiskInfo::equal

    source

    MacosDiskInfo::not_equal

    source
    fn MacosDiskInfo::not_equal(x : MacosDiskInfo, y : MacosDiskInfo) -> Bool

    MacosDiskInfo::output

    source
    fn MacosDiskInfo::output(self : MacosDiskInfo, logger : &Logger) -> Unit

    MacosDiskInfo::to_repr

    source

    MacosDiskInfo::to_string

    source
    fn MacosDiskInfo::to_string(self : MacosDiskInfo) -> String

    MemoryRefreshKind

    source
    pub(all) struct MemoryRefreshKind {
      ram : Bool
      swap : Bool
    } derive(Eq, 
    Debug    )

    MemoryRefreshKind::equal

    source

    MemoryRefreshKind::everything

    source

    MemoryRefreshKind::not_equal

    source
    fn MemoryRefreshKind::not_equal(x : MemoryRefreshKind, y : MemoryRefreshKind) -> Bool

    MemoryRefreshKind::nothing

    source

    MemoryRefreshKind::output

    source
    fn MemoryRefreshKind::output(self : MemoryRefreshKind, logger : &Logger) -> Unit

    MemoryRefreshKind::ram

    source
    fn MemoryRefreshKind::ram(self : MemoryRefreshKind) -> Bool

    MemoryRefreshKind::swap

    source
    fn MemoryRefreshKind::swap(self : MemoryRefreshKind) -> Bool

    MemoryRefreshKind::to_repr

    source

    MemoryRefreshKind::to_string

    source
    fn MemoryRefreshKind::to_string(self : MemoryRefreshKind) -> String

    MemoryRefreshKind::with_ram

    source

    MemoryRefreshKind::with_swap

    source

    MemoryRefreshKind::without_ram

    source

    MemoryRefreshKind::without_swap

    source

    MountEntry

    source
    type MountEntry derive(Eq, 
    Debug    )

    impl Show for MountEntry

    MountEntry::equal

    source
    fn MountEntry::equal(MountEntry, MountEntry) -> Bool

    MountEntry::not_equal

    source
    fn MountEntry::not_equal(x : MountEntry, y : MountEntry) -> Bool

    MountEntry::output

    source
    fn MountEntry::output(self : MountEntry, logger : &Logger) -> Unit

    MountEntry::to_repr

    source

    MountEntry::to_string

    source
    fn MountEntry::to_string(self : MountEntry) -> String

    NetworkData

    source
    pub(all) struct NetworkData {
      received : UInt64
      total_received : UInt64
      transmitted : UInt64
      total_transmitted : UInt64
      packets_received : UInt64
      total_packets_received : UInt64
      packets_transmitted : UInt64
      total_packets_transmitted : UInt64
      errors_on_received : UInt64
      total_errors_on_received : UInt64
      errors_on_transmitted : UInt64
      total_errors_on_transmitted : UInt64
      mac_address : MacAddr
      ip_networks : Array[IpNetwork]
      mtu : UInt64
    } derive(Eq, 
    Debug    )

    impl Show for NetworkData

    NetworkData::equal

    source
    fn NetworkData::equal(NetworkData, NetworkData) -> Bool

    NetworkData::errors_on_received

    source
    fn NetworkData::errors_on_received(self : NetworkData) -> UInt64

    NetworkData::errors_on_transmitted

    source
    fn NetworkData::errors_on_transmitted(self : NetworkData) -> UInt64

    NetworkData::ip_networks

    source
    fn NetworkData::ip_networks(self : NetworkData) -> Array[IpNetwork]

    NetworkData::mac_address

    source
    fn NetworkData::mac_address(self : NetworkData) -> MacAddr

    NetworkData::mtu

    source
    fn NetworkData::mtu(self : NetworkData) -> UInt64

    NetworkData::not_equal

    source
    fn NetworkData::not_equal(x : NetworkData, y : NetworkData) -> Bool

    NetworkData::output

    source
    fn NetworkData::output(self : NetworkData, logger : &Logger) -> Unit

    NetworkData::packets_received

    source
    fn NetworkData::packets_received(self : NetworkData) -> UInt64

    NetworkData::packets_transmitted

    source
    fn NetworkData::packets_transmitted(self : NetworkData) -> UInt64

    NetworkData::received

    source
    fn NetworkData::received(self : NetworkData) -> UInt64

    NetworkData::to_repr

    source

    NetworkData::to_string

    source
    fn NetworkData::to_string(self : NetworkData) -> String

    NetworkData::total_errors_on_received

    source
    fn NetworkData::total_errors_on_received(self : NetworkData) -> UInt64

    NetworkData::total_errors_on_transmitted

    source
    fn NetworkData::total_errors_on_transmitted(self : NetworkData) -> UInt64

    NetworkData::total_packets_received

    source
    fn NetworkData::total_packets_received(self : NetworkData) -> UInt64

    NetworkData::total_packets_transmitted

    source
    fn NetworkData::total_packets_transmitted(self : NetworkData) -> UInt64

    NetworkData::total_received

    source
    fn NetworkData::total_received(self : NetworkData) -> UInt64

    NetworkData::total_transmitted

    source
    fn NetworkData::total_transmitted(self : NetworkData) -> UInt64

    NetworkData::transmitted

    source
    fn NetworkData::transmitted(self : NetworkData) -> UInt64

    Networks

    source
    pub(all) struct Networks {
      networks_data : Map[String, NetworkData]
    } derive(
    Debug    )

    impl Show for Networks

    Networks::list

    source
    fn Networks::list(self : Networks) -> Map[String, NetworkData]

    Networks::new

    source
    fn Networks::new() -> Networks

    Networks::new_with_refreshed_list

    source
    fn Networks::new_with_refreshed_list() -> Networks

    Networks::output

    source
    fn Networks::output(self : Networks, logger : &Logger) -> Unit

    Networks::refresh

    source
    fn Networks::refresh(self : Networks, remove_not_listed_interfaces : Bool) -> Unit

    Networks::to_repr

    source

    Networks::to_string

    source
    fn Networks::to_string(self : Networks) -> String

    Pid

    source
    pub(all) struct Pid {
      value : Int
    } derive(Compare, Eq, Hash, 
    Debug    )

    impl Show for Pid

    Pid::as_u32

    source
    fn Pid::as_u32(self : Pid) -> UInt

    Pid::compare

    source
    fn Pid::compare(Pid, Pid) -> Int

    Pid::equal

    source
    fn Pid::equal(Pid, Pid) -> Bool

    Pid::from

    source
    fn Pid::from(value : Int) -> Pid

    Pid::from_u32

    source
    fn Pid::from_u32(value : UInt) -> Pid

    Pid::hash

    source
    fn Pid::hash(self : Pid) -> Int

    Pid::hash_combine

    source
    fn Pid::hash_combine(Pid, Hasher) -> Unit

    Pid::not_equal

    source
    fn Pid::not_equal(x : Pid, y : Pid) -> Bool

    Pid::op_ge

    source
    fn Pid::op_ge(x : Pid, y : Pid) -> Bool

    Pid::op_gt

    source
    fn Pid::op_gt(x : Pid, y : Pid) -> Bool

    Pid::op_le

    source
    fn Pid::op_le(x : Pid, y : Pid) -> Bool

    Pid::op_lt

    source
    fn Pid::op_lt(x : Pid, y : Pid) -> Bool

    Pid::output

    source
    fn Pid::output(self : Pid, logger : &Logger) -> Unit

    Pid::to_int

    source
    fn Pid::to_int(self : Pid) -> Int

    Pid::to_repr

    source

    Pid::to_string

    source
    fn Pid::to_string(self : Pid) -> String

    Process

    source
    pub(all) struct Process {
      pid : Pid
      parent : Pid?
      name : String
      cmd : Array[String]
      environ : Array[String]
      exe : String?
      cwd : String?
      root : String?
      memory : UInt64
      virtual_memory : UInt64
      status : ProcessStatus
      start_time : UInt64
      run_time : UInt64
      cpu_usage : Double
      accumulated_cpu_time : UInt64
      disk_usage : DiskUsage
      user_id : Uid?
      effective_user_id : Uid?
      group_id : Gid?
      effective_group_id : Gid?
      session_id : Pid?
      tasks : Array[Pid]?
      thread_kind : ThreadKind?
      open_files : Int?
      open_files_limit : Int?
    } derive(Eq, 
    Debug    )

    impl Show for Process

    Process::accumulated_cpu_time

    source
    fn Process::accumulated_cpu_time(self : Process) -> UInt64

    Process::cmd

    source
    fn Process::cmd(self : Process) -> Array[String]

    Process::cpu_usage

    source
    fn Process::cpu_usage(self : Process) -> Double

    Process::cwd

    source
    fn Process::cwd(self : Process) -> String?

    Process::disk_usage

    source
    fn Process::disk_usage(self : Process) -> DiskUsage

    Process::effective_group_id

    source
    fn Process::effective_group_id(self : Process) -> Gid?

    Process::effective_user_id

    source
    fn Process::effective_user_id(self : Process) -> Uid?

    Process::environ

    source
    fn Process::environ(self : Process) -> Array[String]

    Process::equal

    source
    fn Process::equal(Process, Process) -> Bool

    Process::exe

    source
    fn Process::exe(self : Process) -> String?

    Process::exists

    source
    fn Process::exists(self : Process) -> Bool

    Process::group_id

    source
    fn Process::group_id(self : Process) -> Gid?

    Process::kill

    source
    fn Process::kill(self : Process) -> Bool

    Process::kill_and_wait

    source
    fn Process::kill_and_wait(self : Process) -> Result[ExitStatus?, KillError]

    Process::kill_with

    source
    fn Process::kill_with(self : Process, signal : Signal) -> Bool?

    Process::kill_with_and_wait

    source
    fn Process::kill_with_and_wait(self : Process, signal : Signal) -> Result[ExitStatus?, KillError]

    Process::memory

    source
    fn Process::memory(self : Process) -> UInt64

    Process::name

    source
    fn Process::name(self : Process) -> String

    Process::not_equal

    source
    fn Process::not_equal(x : Process, y : Process) -> Bool

    Process::open_files

    source
    fn Process::open_files(self : Process) -> Int?

    Process::open_files_limit

    source
    fn Process::open_files_limit(self : Process) -> Int?

    Process::output

    source
    fn Process::output(self : Process, logger : &Logger) -> Unit

    Process::parent

    source
    fn Process::parent(self : Process) -> Pid?

    Process::pid

    source
    fn Process::pid(self : Process) -> Pid

    Process::root

    source
    fn Process::root(self : Process) -> String?

    Process::run_time

    source
    fn Process::run_time(self : Process) -> UInt64

    Process::session_id

    source
    fn Process::session_id(self : Process) -> Pid?

    Process::start_time

    source
    fn Process::start_time(self : Process) -> UInt64

    Process::status

    source
    fn Process::status(self : Process) -> ProcessStatus

    Process::tasks

    source
    fn Process::tasks(self : Process) -> Array[Pid]?

    Process::thread_kind

    source
    fn Process::thread_kind(self : Process) -> ThreadKind?

    Process::to_repr

    source

    Process::to_string

    source
    fn Process::to_string(self : Process) -> String

    Process::user_id

    source
    fn Process::user_id(self : Process) -> Uid?

    Process::virtual_memory

    source
    fn Process::virtual_memory(self : Process) -> UInt64

    Process::wait

    source
    fn Process::wait(self : Process) -> ExitStatus?

    ProcessRefreshKind

    source
    pub(all) struct ProcessRefreshKind {
      cpu : Bool
      disk_usage : Bool
      memory : Bool
      user : UpdateKind
      cwd : UpdateKind
      root : UpdateKind
      environ : UpdateKind
      cmd : UpdateKind
      exe : UpdateKind
      tasks : Bool
    } derive(Eq, 
    Debug    )

    ProcessRefreshKind::cmd

    source

    ProcessRefreshKind::cpu

    source
    fn ProcessRefreshKind::cpu(self : ProcessRefreshKind) -> Bool

    ProcessRefreshKind::cwd

    source

    ProcessRefreshKind::disk_usage

    source
    fn ProcessRefreshKind::disk_usage(self : ProcessRefreshKind) -> Bool

    ProcessRefreshKind::environ

    source

    ProcessRefreshKind::equal

    source

    ProcessRefreshKind::everything

    source

    ProcessRefreshKind::exe

    source

    ProcessRefreshKind::memory

    source
    fn ProcessRefreshKind::memory(self : ProcessRefreshKind) -> Bool

    ProcessRefreshKind::not_equal

    source

    ProcessRefreshKind::nothing

    source

    ProcessRefreshKind::output

    source
    fn ProcessRefreshKind::output(self : ProcessRefreshKind, logger : &Logger) -> Unit

    ProcessRefreshKind::root

    source

    ProcessRefreshKind::tasks

    source
    fn ProcessRefreshKind::tasks(self : ProcessRefreshKind) -> Bool

    ProcessRefreshKind::to_repr

    source

    ProcessRefreshKind::to_string

    source
    fn ProcessRefreshKind::to_string(self : ProcessRefreshKind) -> String

    ProcessRefreshKind::user

    source

    ProcessRefreshKind::with_cmd

    source

    ProcessRefreshKind::with_cpu

    source

    ProcessRefreshKind::with_cwd

    source

    ProcessRefreshKind::with_disk_usage

    source

    ProcessRefreshKind::with_environ

    source

    ProcessRefreshKind::with_exe

    source

    ProcessRefreshKind::with_memory

    source

    ProcessRefreshKind::with_root

    source

    ProcessRefreshKind::with_tasks

    source

    ProcessRefreshKind::with_user

    source

    ProcessRefreshKind::without_cmd

    source

    ProcessRefreshKind::without_cpu

    source

    ProcessRefreshKind::without_cwd

    source

    ProcessRefreshKind::without_disk_usage

    source
    fn ProcessRefreshKind::without_disk_usage(self : ProcessRefreshKind) -> ProcessRefreshKind

    ProcessRefreshKind::without_environ

    source

    ProcessRefreshKind::without_exe

    source

    ProcessRefreshKind::without_memory

    source

    ProcessRefreshKind::without_root

    source

    ProcessRefreshKind::without_tasks

    source

    ProcessRefreshKind::without_user

    source

    ProcessStatus

    source
    pub(all) enum ProcessStatus {
      Dead
      Idle
      LockBlocked
      Parked
      Run
      Sleep
      Stop
      Suspended
      Tracing
      UninterruptibleDiskSleep
      Unknown(Int)
      Wakekill
      Waking
      Zombie
    } derive(Eq, 
    Debug    )

    ProcessStatus::equal

    source

    ProcessStatus::not_equal

    source
    fn ProcessStatus::not_equal(x : ProcessStatus, y : ProcessStatus) -> Bool

    ProcessStatus::output

    source
    fn ProcessStatus::output(self : ProcessStatus, logger : &Logger) -> Unit

    ProcessStatus::to_repr

    source

    ProcessStatus::to_string

    source
    fn ProcessStatus::to_string(self : ProcessStatus) -> String

    ProcessesToUpdate

    source
    pub(all) enum ProcessesToUpdate {
      All
      Selected(Array[Pid])
    } derive(Eq, 
    Debug    )

    ProcessesToUpdate::equal

    source

    ProcessesToUpdate::not_equal

    source
    fn ProcessesToUpdate::not_equal(x : ProcessesToUpdate, y : ProcessesToUpdate) -> Bool

    ProcessesToUpdate::output

    source
    fn ProcessesToUpdate::output(self : ProcessesToUpdate, logger : &Logger) -> Unit

    ProcessesToUpdate::to_repr

    source

    ProcessesToUpdate::to_string

    source
    fn ProcessesToUpdate::to_string(self : ProcessesToUpdate) -> String

    RefreshKind

    source
    pub(all) struct RefreshKind {
      processes : ProcessRefreshKind?
      memory : MemoryRefreshKind?
      cpu : CpuRefreshKind?
    } derive(Eq, 
    Debug    )

    impl Show for RefreshKind

    RefreshKind::cpu

    source

    RefreshKind::equal

    source
    fn RefreshKind::equal(RefreshKind, RefreshKind) -> Bool

    RefreshKind::everything

    source
    fn RefreshKind::everything() -> RefreshKind

    RefreshKind::memory

    source

    RefreshKind::not_equal

    source
    fn RefreshKind::not_equal(x : RefreshKind, y : RefreshKind) -> Bool

    RefreshKind::nothing

    source
    fn RefreshKind::nothing() -> RefreshKind

    RefreshKind::output

    source
    fn RefreshKind::output(self : RefreshKind, logger : &Logger) -> Unit

    RefreshKind::processes

    source
    fn RefreshKind::processes(self : RefreshKind) -> ProcessRefreshKind?

    RefreshKind::to_repr

    source

    RefreshKind::to_string

    source
    fn RefreshKind::to_string(self : RefreshKind) -> String

    RefreshKind::with_cpu

    source
    fn RefreshKind::with_cpu(self : RefreshKind, kind : CpuRefreshKind) -> RefreshKind

    RefreshKind::with_memory

    source
    fn RefreshKind::with_memory(self : RefreshKind, kind : MemoryRefreshKind) -> RefreshKind

    RefreshKind::with_processes

    source
    fn RefreshKind::with_processes(self : RefreshKind, kind : ProcessRefreshKind) -> RefreshKind

    RefreshKind::without_cpu

    source
    fn RefreshKind::without_cpu(self : RefreshKind) -> RefreshKind

    RefreshKind::without_memory

    source
    fn RefreshKind::without_memory(self : RefreshKind) -> RefreshKind

    RefreshKind::without_processes

    source
    fn RefreshKind::without_processes(self : RefreshKind) -> RefreshKind

    Signal

    source
    pub(all) enum Signal {
      Abort
      Alarm
      Bus
      Child
      Continue
      FloatingPointException
      Hangup
      IO
      IOT
      Illegal
      Interrupt
      Kill
      Pipe
      Poll
      Power
      Profiling
      Quit
      Segv
      Stop
      Sys
      TSTP
      TTIN
      TTOU
      Term
      Trap
      Urgent
      User1
      User2
      VirtualAlarm
      Winch
      XCPU
      XFSZ
    } derive(Eq, 
    Debug    )

    impl Show for Signal

    Signal::equal

    source
    fn Signal::equal(Signal, Signal) -> Bool

    Signal::not_equal

    source
    fn Signal::not_equal(x : Signal, y : Signal) -> Bool

    Signal::output

    source
    fn Signal::output(self : Signal, logger : &Logger) -> Unit

    Signal::to_repr

    source

    Signal::to_string

    source
    fn Signal::to_string(self : Signal) -> String

    System

    source
    pub(all) struct System {
      processes_data : Map[Pid, Process]
      cpus_data : Array[Cpu]
      total_memory_data : UInt64
      free_memory_data : UInt64
      available_memory_data : UInt64
      used_memory_data : UInt64
      total_swap_data : UInt64
      free_swap_data : UInt64
      used_swap_data : UInt64
      cgroup_limits_data : CGroupLimits?
      last_cpu_refresh_ms : UInt64
      prev_cpu_snapshots : Array[CpuSnapshot]
      prev_global_cpu_snapshot : CpuSnapshot?
      prev_proc_cpu_total : Map[Pid, UInt64]
      prev_proc_system_total : UInt64
    }

    System::available_memory

    source
    fn System::available_memory(self : System) -> UInt64

    System::boot_time

    source
    fn System::boot_time() -> UInt64

    System::cgroup_limits

    source
    fn System::cgroup_limits(self : System) -> CGroupLimits?

    System::cpu_arch

    source
    fn System::cpu_arch() -> String

    System::cpus

    source
    fn System::cpus(self : System) -> Array[Cpu]

    System::distribution_id

    source
    fn System::distribution_id() -> String

    System::distribution_id_like

    source
    fn System::distribution_id_like() -> Array[String]

    System::free_memory

    source
    fn System::free_memory(self : System) -> UInt64

    System::free_swap

    source
    fn System::free_swap(self : System) -> UInt64

    System::global_cpu_usage

    source
    fn System::global_cpu_usage(self : System) -> Double

    System::host_name

    source
    fn System::host_name() -> String?

    System::kernel_long_version

    source
    fn System::kernel_long_version() -> String

    System::kernel_version

    source
    fn System::kernel_version() -> String?

    System::load_average

    source
    fn System::load_average() -> LoadAvg

    System::long_os_version

    source
    fn System::long_os_version() -> String?

    System::name

    source
    fn System::name() -> String?

    System::new

    source
    fn System::new() -> System

    System::new_all

    source
    fn System::new_all() -> System

    System::new_with_specifics

    source
    fn System::new_with_specifics(refreshes : RefreshKind) -> System

    System::open_files_limit

    source
    fn System::open_files_limit() -> Int?

    System::os_version

    source
    fn System::os_version() -> String?

    System::physical_core_count

    source
    fn System::physical_core_count() -> Int?

    System::process

    source
    fn System::process(self : System, pid : Pid) -> Process?

    System::processes

    source
    fn System::processes(self : System) -> Map[Pid, Process]

    System::processes_by_exact_name

    source
    fn System::processes_by_exact_name(self : System, name : String) -> Array[(Pid, Process)]

    System::processes_by_name

    source
    fn System::processes_by_name(self : System, name : String) -> Array[(Pid, Process)]

    System::refresh_all

    source
    fn System::refresh_all(self : System) -> Unit

    System::refresh_cpu_all

    source
    fn System::refresh_cpu_all(self : System) -> Unit

    System::refresh_cpu_frequency

    source
    fn System::refresh_cpu_frequency(self : System) -> Unit

    System::refresh_cpu_list

    source
    fn System::refresh_cpu_list(self : System, refresh_kind : CpuRefreshKind) -> Unit

    System::refresh_cpu_specifics

    source
    fn System::refresh_cpu_specifics(self : System, refresh_kind : CpuRefreshKind) -> Unit

    System::refresh_cpu_usage

    source
    fn System::refresh_cpu_usage(self : System) -> Unit

    System::refresh_memory

    source
    fn System::refresh_memory(self : System) -> Unit

    System::refresh_memory_specifics

    source
    fn System::refresh_memory_specifics(self : System, refresh_kind : MemoryRefreshKind) -> Unit

    System::refresh_processes

    source
    fn System::refresh_processes(self : System, processes_to_update : ProcessesToUpdate, remove_dead_processes : Bool) -> Int

    System::refresh_processes_specifics

    source
    fn System::refresh_processes_specifics(self : System, processes_to_update : ProcessesToUpdate, remove_dead_processes : Bool, refresh_kind : ProcessRefreshKind) -> Int

    System::refresh_specifics

    source
    fn System::refresh_specifics(self : System, refreshes : RefreshKind) -> Unit

    System::total_memory

    source
    fn System::total_memory(self : System) -> UInt64

    System::total_swap

    source
    fn System::total_swap(self : System) -> UInt64

    System::uptime

    source
    fn System::uptime() -> UInt64

    System::used_memory

    source
    fn System::used_memory(self : System) -> UInt64

    System::used_swap

    source
    fn System::used_swap(self : System) -> UInt64

    ThreadKind

    source
    pub(all) enum ThreadKind {
      Kernel
      Userland
    } derive(Eq, 
    Debug    )

    impl Show for ThreadKind

    ThreadKind::equal

    source
    fn ThreadKind::equal(ThreadKind, ThreadKind) -> Bool

    ThreadKind::not_equal

    source
    fn ThreadKind::not_equal(x : ThreadKind, y : ThreadKind) -> Bool

    ThreadKind::output

    source
    fn ThreadKind::output(self : ThreadKind, logger : &Logger) -> Unit

    ThreadKind::to_repr

    source

    ThreadKind::to_string

    source
    fn ThreadKind::to_string(self : ThreadKind) -> String

    Uid

    source
    pub(all) struct Uid {
      value : Int
    } derive(Compare, Eq, Hash, 
    Debug    )

    impl Show for Uid

    Uid::compare

    source
    fn Uid::compare(Uid, Uid) -> Int

    Uid::equal

    source
    fn Uid::equal(Uid, Uid) -> Bool

    Uid::from

    source
    fn Uid::from(value : Int) -> Uid

    Uid::hash

    source
    fn Uid::hash(self : Uid) -> Int

    Uid::hash_combine

    source
    fn Uid::hash_combine(Uid, Hasher) -> Unit

    Uid::not_equal

    source
    fn Uid::not_equal(x : Uid, y : Uid) -> Bool

    Uid::op_ge

    source
    fn Uid::op_ge(x : Uid, y : Uid) -> Bool

    Uid::op_gt

    source
    fn Uid::op_gt(x : Uid, y : Uid) -> Bool

    Uid::op_le

    source
    fn Uid::op_le(x : Uid, y : Uid) -> Bool

    Uid::op_lt

    source
    fn Uid::op_lt(x : Uid, y : Uid) -> Bool

    Uid::output

    source
    fn Uid::output(self : Uid, logger : &Logger) -> Unit

    Uid::to_int

    source
    fn Uid::to_int(self : Uid) -> Int

    Uid::to_repr

    source

    Uid::to_string

    source
    fn Uid::to_string(self : Uid) -> String

    UpdateKind

    source
    pub(all) enum UpdateKind {
      Never
      Always
      OnlyIfNotSet
    } derive(Eq, 
    Debug    )

    impl Show for UpdateKind

    UpdateKind::equal

    source
    fn UpdateKind::equal(UpdateKind, UpdateKind) -> Bool

    UpdateKind::not_equal

    source
    fn UpdateKind::not_equal(x : UpdateKind, y : UpdateKind) -> Bool

    UpdateKind::output

    source
    fn UpdateKind::output(self : UpdateKind, logger : &Logger) -> Unit

    UpdateKind::to_repr

    source

    UpdateKind::to_string

    source
    fn UpdateKind::to_string(self : UpdateKind) -> String

    User

    source
    pub(all) struct User {
      id : Uid
      group_id : Gid
      name : String
      groups : Array[Group]
    } derive(Eq, 
    Debug    )

    impl Show for User

    User::equal

    source
    fn User::equal(User, User) -> Bool

    User::group_id

    source
    fn User::group_id(self : User) -> Gid

    User::groups

    source
    fn User::groups(self : User) -> Array[Group]

    User::id

    source
    fn User::id(self : User) -> Uid

    User::name

    source
    fn User::name(self : User) -> String

    User::not_equal

    source
    fn User::not_equal(x : User, y : User) -> Bool

    User::output

    source
    fn User::output(self : User, logger : &Logger) -> Unit

    User::to_repr

    source

    User::to_string

    source
    fn User::to_string(self : User) -> String

    Users

    source
    pub(all) struct Users {
      users_data : Array[User]
    } derive(
    Debug    )

    impl Show for Users

    Users::get_user_by_id

    source
    fn Users::get_user_by_id(self : Users, user_id : Uid) -> User?

    Users::list

    source
    fn Users::list(self : Users) -> Array[User]

    Users::list_mut

    source
    fn Users::list_mut(self : Users) -> Array[User]

    Users::new

    source
    fn Users::new() -> Users

    Users::new_with_refreshed_list

    source
    fn Users::new_with_refreshed_list() -> Users

    Users::output

    source
    fn Users::output(self : Users, logger : &Logger) -> Unit

    Users::refresh

    source
    fn Users::refresh(self : Users) -> Unit

    Users::to_repr

    source

    Users::to_string

    source
    fn Users::to_string(self : Users) -> String

    MINIMUM_CPU_UPDATE_INTERVAL

    source
    let MINIMUM_CPU_UPDATE_INTERVAL : Int

    get_current_pid

    source
    fn get_current_pid() -> Result[Pid, String]

    is_supported_system

    source
    let is_supported_system : Bool

    set_open_files_limit

    source
    fn set_open_files_limit(new_limit : Int) -> Bool

    supported_signals

    source
    let supported_signals : Array[Signal]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io