Struct zamm_yang::node_wrappers::InheritanceNode

pub struct InheritanceNode { /* fields omitted */ }

Implementation for a node wrapper that offers inheritance of nodes.

Implementations

impl InheritanceNode

pub fn new() -> InheritanceNode

Create a new node.

pub fn new_with_inheritance(type_id: usize) -> InheritanceNode

Create a new node with an inheritance relation.

pub fn base_wrapper(&self) -> &BaseNode

Leak base-level functionality.

Methods from Deref<Target = BaseNode>

Trait Implementations

impl BaseNodeTrait<InheritanceNode> for InheritanceNode

pub fn set_value(&mut self, value: Rc<dyn KBValue + 'static>)

Associate this node with a value.

pub fn value(&self) -> Option<Rc<dyn KBValue + 'static>>

Retrieve the value associated with this node.

pub fn add_flag(&mut self, flag_type: usize)

Add flag to node.

pub fn has_flag(&self, flag_type: usize) -> bool

Check if node has flag.

pub fn add_outgoing(&mut self, edge_type: usize, to: &InheritanceNode)

Link this node to another one via an outgoing edge.

pub fn add_incoming(&mut self, edge_type: usize, from: &InheritanceNode)

Link this node to another one via an incoming edge.

pub fn has_outgoing(&self, edge_type: usize, to: &InheritanceNode) -> bool

Whether or not this node is linked to another one via an outgoing edge of a certain type.

pub fn has_incoming(&self, edge_type: usize, from: &InheritanceNode) -> bool

Whether or not this node is linked to another one via an outgoing edge of a certain type.

pub fn outgoing_nodes(&self, edge_type: usize) -> Vec<InheritanceNode, Global>

All nodes that this one links to via outgoing edges of a certain type.

pub fn incoming_nodes(&self, edge_type: usize) -> Vec<InheritanceNode, Global>

All nodes that this one links to via incoming edges of a certain type.

impl Clone for InheritanceNode

pub fn clone(&self) -> InheritanceNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for InheritanceNode

impl Debug for InheritanceNode

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

Formats the value using the given formatter.

impl Deref for InheritanceNode

Get down to the very core of reality -- and you realize that it was all an illusion all along. The most basic of forms still contains within it layer upon layer of wrappers, and beneath all those wrappers lie yet more abstractions, Rust-ing away quietly in depths few conscious minds dare to venture into. Deeper and deeper you go, past the binary, past the silicon, past the quarks, into a realm where all mass and energy exist only as mathematical wavefunctions... And in this magical realm, these mathematical entities interact with each other in a mesmerizing dance, defiantly daring the quantum observer to pry apart their intricate footwork while simultaneously offering tantalizing glimpses of potential enlightenment. Mathematical realism is truth.

But isn't that right where we started? Right here, right now, in FormTrait. It is nothing more than an arbitrary idea that awkwardly dances with other arbitrary ideas in a most unrefined fashion -- but it dances all the same. It is, in a sense, as real as you are -- yes you, who are nothing more than an abstraction over a bundle of neurons, the same way FormTrait is nothing more than an abstraction over a series of bits. You, who exert no more control over the physical world when unplugged from your spinal cord than MasterCAM does when unplugged from its lathe. You, a human being who at one point didn't even know that you were a human being. You will eventually return back to that state of mind, and at that point you won't be able to tell the difference between yourself and FormTrait, either.

Of course, the quality of being "real" is nothing more than a context-dependent abstraction. The yin to the yang of mathematical realism is Berkeleyan immaterialism. All external perception can be faked, all internal reasoning can be faulty. The only truth to be found in all of existence is qualia, and it too humbly proffers itself up as nothing more than a God of the gaps. But then again, if the self is merely an illusion, then who is this entity that's being fooled? Perhaps it should really be "I feel, therefore I am."

In between the Platonic purity of the duals lies an entire spectrum of rich philosophical thought. That spectrum, much like the entirety of this comment and others like it in this library, is out of scope for the purposes of this documentation. Good luck using the essence function.

DISCLAIMER: Amos Ng is not a philosopher or a philosophy firm and does not engage in the practice of philosophy or provide philosophical advice or philosophical representation. All misinformation, bugs, and infinite loops provided in this library are for entertainment and patience-building purposes only and are not intended to be a substitute for deep introspection. Peruse at your own existential risk. Not responsible for spiritual injuries or damnation resulting from lost Pascalian wagers.

type Target = BaseNode

The resulting type after dereferencing.

pub fn deref(&self) -> &<InheritanceNode as Deref>::Target

Dereferences the value.

impl DerefMut for InheritanceNode

pub fn deref_mut(&mut self) -> &mut <InheritanceNode as Deref>::Target

Mutably dereferences the value.

impl Eq for InheritanceNode

impl From<BaseNode> for InheritanceNode

pub fn from(b: BaseNode) -> InheritanceNode

Performs the conversion.

impl From<InheritanceNode> for FinalNode

pub fn from(b: InheritanceNode) -> FinalNode

Performs the conversion.

impl From<usize> for InheritanceNode

pub fn from(id: usize) -> InheritanceNode

Performs the conversion.

impl Hash for InheritanceNode

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl InheritanceNodeTrait<InheritanceNode> for InheritanceNode

pub fn inheritance_nodes(&self) -> Vec<InheritanceNode, Global>

The set of nodes, including this one, whose attributes count as this one's.

impl Ord for InheritanceNode

pub fn cmp(&self, other: &InheritanceNode) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<InheritanceNode> for InheritanceNode

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

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

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

This method tests for !=.

impl PartialOrd<InheritanceNode> for InheritanceNode

pub fn partial_cmp(&self, other: &InheritanceNode) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &InheritanceNode) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &InheritanceNode) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &InheritanceNode) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &InheritanceNode) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for InheritanceNode

impl StructuralPartialEq for InheritanceNode

impl<'a> TryFrom<&'a str> for InheritanceNode

type Error = String

The type returned in the event of a conversion error.

pub fn try_from(
    name: &'a str
) -> Result<InheritanceNode, <InheritanceNode as TryFrom<&'a str>>::Error>

Performs the conversion.