Type Alias makepad_widgets::shader::std::LiveRef

pub type LiveRef = Option<LivePtr>;

Aliased Type

enum LiveRef {
    None,
    Some(LivePtr),
}

Variants

None

No value.

Some(LivePtr)

Some value of type T.

Trait Implementations

impl<T> DeBin for Option<T>where T: DeBin,

fn de_bin(o: &mut usize, d: &[u8]) -> Result<Option<T>, DeBinErr>

fn deserialize_bin(d: &[u8]) -> Result<Self, DeBinErr>

impl<T> DeJson for Option<T>where T: DeJson,

fn de_json( s: &mut DeJsonState, i: &mut Chars<'_> ) -> Result<Option<T>, DeJsonErr>

fn deserialize_json(input: &str) -> Result<Self, DeJsonErr>

impl<T> DeRon for Option<T>where T: DeRon,

fn de_ron(s: &mut DeRonState, i: &mut Chars<'_>) -> Result<Option<T>, DeRonErr>

fn deserialize_ron(input: &str) -> Result<Self, DeRonErr>

impl<T> Hash for Option<T>where T: Hash,

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> LiveApply for Option<T>where T: LiveApply + LiveNew + 'static,

fn apply( &mut self, cx: &mut Cx, from: ApplyFrom, index: usize, nodes: &[LiveNode] ) -> usize

fn apply_over(&mut self, cx: &mut Cx, nodes: &[LiveNode])

impl<T> LiveHook for Option<T>where T: LiveApply + LiveNew + 'static,

fn before_live_design(_cx: &mut Cx)

fn apply_value_unknown( &mut self, cx: &mut Cx, _apply_from: ApplyFrom, index: usize, nodes: &[LiveNode] ) -> usize

fn apply_value_instance( &mut self, _cx: &mut Cx, _apply_from: ApplyFrom, index: usize, nodes: &[LiveNode] ) -> usize

fn skip_apply( &mut self, _cx: &mut Cx, _apply_from: ApplyFrom, _index: usize, _nodes: &[LiveNode] ) -> Option<usize>

fn before_apply( &mut self, _cx: &mut Cx, _apply_from: ApplyFrom, _index: usize, _nodes: &[LiveNode] )

fn after_apply( &mut self, _cx: &mut Cx, _apply_from: ApplyFrom, _index: usize, _nodes: &[LiveNode] )

fn after_apply_from(&mut self, cx: &mut Cx, apply_from: ApplyFrom)

fn after_new_from_doc(&mut self, _cx: &mut Cx)

fn after_new_before_apply(&mut self, _cx: &mut Cx)

impl<T> LiveNew for Option<T>where T: LiveApply + LiveNew + 'static,

fn new(_cx: &mut Cx) -> Option<T>

fn new_apply( cx: &mut Cx, from: ApplyFrom, index: usize, nodes: &[LiveNode] ) -> Option<T>

fn live_type_info(_cx: &mut Cx) -> LiveTypeInfo

fn live_design_with(_cx: &mut Cx)

fn new_apply_mut_index( cx: &mut Cx, from: ApplyFrom, index: &mut usize, nodes: &[LiveNode] ) -> Selfwhere Self: Sized,

fn new_from_ptr(cx: &mut Cx, live_ptr: Option<LivePtr>) -> Selfwhere Self: Sized,

fn new_main(cx: &mut Cx) -> Selfwhere Self: Sized,

fn update_main(&mut self, cx: &mut Cx)

fn new_local(cx: &mut Cx) -> Selfwhere Self: Sized,

fn new_from_module( cx: &mut Cx, module_id: LiveModuleId, id: LiveId ) -> Option<Self>where Self: Sized,

fn update_from_module( &mut self, cx: &mut Cx, module_id: LiveModuleId, id: LiveId )

impl<T> SerBin for Option<T>where T: SerBin,

fn ser_bin(&self, s: &mut Vec<u8, Global>)

fn serialize_bin(&self) -> Vec<u8, Global>

impl<T> SerJson for Option<T>where T: SerJson,

fn ser_json(&self, d: usize, s: &mut SerJsonState)

fn serialize_json(&self) -> String

impl<T> SerRon for Option<T>where T: SerRon,

fn ser_ron(&self, d: usize, s: &mut SerRonState)

fn serialize_ron(&self) -> String