Struct State

pub struct State {
    pub power: Option<String>,
    pub color: Option<String>,
    pub brightness: Option<f64>,
    pub duration: Option<f64>,
    pub infrared: Option<f64>,
    pub selector: Option<String>,
    pub fast: Option<bool>,
}

Used to descripe the state of an LIFX Light Source

Fields

power: Option<String>

The power state you want to set on the selector. on or off

color: Option<String>

The color to set the light to.

brightness: Option<f64>

The brightness level from 0.0 to 1.0. Overrides any brightness set in color (if any).

duration: Option<f64>

How long in seconds you want the power action to take. Range: 0.0 – 3155760000.0 (100 years)

infrared: Option<f64>

The maximum brightness of the infrared channel from 0.0 to 1.0.

selector: Option<String>

The selector to limit which light to use for set_states()

fast: Option<bool>

Execute the query fast, without initial state checks and wait for no results.

Implementations

impl State

pub fn new() -> Self

Returns a new State object

Examples

extern crate lifx_rs as lifx;
 
fn main() {
 
    let key = "xxx".to_string();
    let mut api_endpoints: Vec<String> = Vec::new();

    api_endpoints.push(format!("https://api.lifx.com"));
    api_endpoints.push(format!("http://localhost:8089"));

    let config = lifx::LifxConfig{
       access_token: key.clone(),
       api_endpoints: api_endpoints
    };
 
    let mut state = lifx::State::new();
    state.power = Some(format!("off"));
}

Trait Implementations

impl Clone for State

fn clone(&self) -> State

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for State

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

Formats the value using the given formatter.

impl Default for State

fn default() -> State

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for State

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for State

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for State

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for State