Struct sysctl::Ctl

pub struct Ctl {
    pub oid: Vec<c_int>,
}

This struct represents a system control.

Fields

oid: Vec<c_int>

Methods

impl Ctl

pub fn new(name: &str) -> Result<Self, SysctlError>

Construct a Ctl from the name.

This is just a wrapper around Ctl::from_str.

Returns a result containing the struct Ctl on success or a SysctlError on failure.

Example

extern crate sysctl;
use sysctl::Ctl;

let ctl = Ctl::new("kern.osrelease");

If the sysctl does not exist, Err(SysctlError::NotFound) is returned.

extern crate sysctl;
use sysctl::{Ctl, SysctlError};

let ctl = Ctl::new("this.sysctl.does.not.exist");
match ctl {
    Err(SysctlError::NotFound(_)) => (),
    Err(_) => panic!("Wrong error type returned"),
    Ok(_) => panic!("Nonexistent sysctl seems to exist"),
}

pub fn name(&self) -> Result<String, SysctlError>

Returns a result containing the sysctl name on success, or a SysctlError on failure.

Example

let ctl = Ctl::new("kern.osrelease").expect("could not get sysctl");
assert_eq!(ctl.name().expect("could not get name"), "kern.osrelease");

pub fn value_type(&self) -> Result<CtlType, SysctlError>

Returns a result containing the sysctl value type on success, or a Sysctl Error on failure.

Example

let ctl = Ctl::new("kern.osrelease")
    .expect("Could not get kern.osrelease sysctl");
let value_type = ctl.value_type()
        .expect("Could not get kern.osrelease value type");
assert_eq!(value_type, CtlType::String);

pub fn description(&self) -> Result<String, SysctlError>

Returns a result containing the sysctl description if success, or an Error on failure.

Example

extern crate sysctl;
use sysctl::Ctl;

fn main() {
    let osrevision = sysctl::Ctl::new("kern.osrevision")
        .expect("could not get kern.osrevision sysctl");
    println!("Description: {:?}", osrevision.description())
}

pub fn value(&self) -> Result<CtlValue, SysctlError>

Returns a result containing the sysctl value on success, or a SysctlError on failure.

Example

extern crate sysctl;
extern crate libc;

fn main() {
    let osrevision = sysctl::Ctl::new("kern.osrevision")
        .expect("could not get kern.osrevisio sysctl");
    println!("Value: {:?}", osrevision.value());
}

pub fn value_as<T>(&self) -> Result<Box<T>, SysctlError>

A generic method that takes returns a result containing the sysctl value if success, or a SysctlError on failure.

May only be called for sysctls of type Opaque or Struct.

Example

extern crate sysctl;
extern crate libc;

use libc::c_int;

#[derive(Debug)]
#[repr(C)]
struct ClockInfo {
    hz: c_int, /* clock frequency */
    tick: c_int, /* micro-seconds per hz tick */
    spare: c_int,
    stathz: c_int, /* statistics clock frequency */
    profhz: c_int, /* profiling clock frequency */
}

fn main() {
    let clockrate = sysctl::Ctl::new("kern.clockrate")
        .expect("could not get clockrate sysctl");
    println!("{:?}", clockrate.value_as::<ClockInfo>());
}

pub fn set_value(&self, value: CtlValue) -> Result<CtlValue, SysctlError>

Sets the value of a sysctl. Fetches and returns the new value if successful, or returns a SysctlError on failure.

Example

extern crate sysctl;
use sysctl::Ctl;

fn main() {
    let usbdebug = Ctl::new("hw.usb.debug")
        .expect("could not get hw.usb.debug control");
    let set = usbdebug.set_value(sysctl::CtlValue::Int(1))
        .expect("could not set value");
    assert_eq!(set, sysctl::CtlValue::Int(1));
    println!("hw.usb.debug: -> {:?}", set);
}

pub fn flags(&self) -> Result<CtlFlags, SysctlError>

Get the flags for a sysctl.

Returns a Result containing the flags on success, or a SysctlError on failure.

Example

extern crate sysctl;
use sysctl::{Ctl, CtlFlags};

fn main() {
    let osrev = Ctl::new("kern.osrevision")
        .expect("could not get control");

    let readable = osrev.flags()
        .expect("could not get flags")
        .contains(CtlFlags::RD);

    assert!(readable);
}

pub fn info(&self) -> Result<CtlInfo, SysctlError>

Returns a Result containing the control metadata for a sysctl.

Returns a Result containing the CtlInfo struct on success, or a SysctlError on failure.

Example

extern crate sysctl;
use sysctl::{Ctl, CtlInfo};

fn main() {
    let osrev = Ctl::new("kern.osrevision")
        .expect("could not get control");

    let info = osrev.info()
        .expect("could not get info");

    // kern.osrevision is not a structure.
    assert_eq!(info.struct_type(), None);
}

Trait Implementations

impl Debug for Ctl

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for Ctl

fn clone(&self) -> Ctl

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl PartialEq for Ctl

fn eq(&self, other: &Ctl) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Ctl) -> bool

This method tests for !=.

impl FromStr for Ctl

type Err = SysctlError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl IntoIterator for Ctl

Ctl implements the IntoIterator trait to allow for easy iteration over nodes.

Example

extern crate sysctl;
use sysctl::Ctl;

let kern = Ctl::new("kern");
for ctl in kern {
    let name = ctl.name().expect("could not get name");
    println!("{}", name);
}

type Item = Result<Ctl, SysctlError>

The type of the elements being iterated over.

type IntoIter = CtlIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.