Struct GKRuleSystem 

pub struct GKRuleSystem { /* private fields */ }

Available on crate feature GKRuleSystem only.

A rule system consists of 3 things:

• The current state, which upon creation is considered the inital state.
• The current set of rules.
• The current set of facts.

Each time a fact is added to the system, the set of rules are evaluated in order and their actions executed in the system if their predicates are true. Rules can be fuzzy, allowing predicates and facts to be asserted to a degree of confidence instead of just boolean on/off.

The facts can be any kind of objects as long as they correctly determine equality using isEqual: The simplest approach is to use strings or dictionaries as they provide the most flexibility in defining facts, but user defined classes work just as well and may describe the problem space better.

The fact set is at all times a fuzzy set, as defined by fact membership in the set being modulated by their grade of membership. The rules may use the grade of membership to predicate their actions and in such a manner create fuzzy logic. The fuzzy logic Zadeh operators are available on the system itself in order to query multiple facts for combined membership grade.

See also Apple’s documentation

Implementations

impl GKRuleSystem

pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>

Initializes a clean rule system with no state, rules or facts.

pub unsafe fn evaluate(&self)

Explicitly evaluate the agenda of the rule system based on the current state and the current set of facts.

This may in turn assert or retract more facts or change the state of the system, including activating more rules in the agenda.

pub unsafe fn state(&self) -> Retained<NSMutableDictionary>

The implementation-defined state. If any changes are made on this outside the system you must call evaluate to have the system take account of the changes.

See: evaluate

Safety

The returned generic should be of the correct type.

pub unsafe fn rules(&self) -> Retained<NSArray<GKRule>>

The current set of rules that will be used to set the agenda when rules are first added to the system. They will also be used to refill the agenda whenever it is set.

This is at all times the union of the agenda and executed sets.

See: agenda

See: executed

pub unsafe fn addRule(&self, rule: &GKRule)

Adds a rule to the system. Also adds it to the agenda in salience order.

pub unsafe fn addRulesFromArray(&self, rules: &NSArray<GKRule>)

Adds rules to the system. Also adds them to the agenda in salience order.

pub unsafe fn removeAllRules(&self)

Removes all rules from the system. This also removes them from the agenda and executed sets.

pub unsafe fn agenda(&self) -> Retained<NSArray<GKRule>>

The current set of rules to be evaluated, in salience order, where if the salience is equivalent the order of insertion into the agenda is used to decide which is first. Adjust salience of your rules to adjust the order the next time the agenda is reset. Changing salience on a rule currently in the agenda does not change its order in the agenda.

This is at all times the difference between the rules and executed sets.

See: rules

See: executed

See: reset

pub unsafe fn executed(&self) -> Retained<NSArray<GKRule>>

The current set of rules that have already executed. Rules in this set will not be executed again until the system is reset.

This is at all times the difference between the rules and agenda sets.

See: rules

See: agenda

See: reset

pub unsafe fn facts(&self) -> Retained<NSArray>

The current set of facts. Facts have a grade of membership that is >= 0.0. Query the system for the individual grades of membership with gradeForFact:

See: gradeForFact:

pub unsafe fn gradeForFact( &self, fact: &ProtocolObject<dyn NSObjectProtocol>, ) -> c_float

Returns the current membership grade for the given fact, which is 0.0 if the fact is not a member of the current set of facts.

Returns: The membership grade of the given fact, in the range [0.0, 1.0].

Safety

fact should be of the correct type.

pub unsafe fn minimumGradeForFacts(&self, facts: &NSArray) -> c_float

Returns the combined membership grade for the all the given facts.

This performs the logical AND operation between the given facts.

Returns: The membership grade by applying the AND operator on the given facts, in the range [0.0, 1.0].

Safety

facts generic should be of the correct type.

pub unsafe fn maximumGradeForFacts(&self, facts: &NSArray) -> c_float

Returns the maximum membership grade for the any one of the given facts.

This performs the logical OR operation between the given facts.

Returns: The membership grade by applying the OR operator on the given facts, in the range [0.0, 1.0].

Safety

facts generic should be of the correct type.

pub unsafe fn assertFact(&self, fact: &ProtocolObject<dyn NSObjectProtocol>)

Asserts a fact with membership grade of 1.0.

This will cause the current rules to be evaluated, which may in turn assert or retract more facts or change the state of the system.

This is shorthand for calling assertFact:grade: with a grade of 1.0

See: assertFact:grade:

See: evaluate

See: NSObject.isEqual:

Safety

fact should be of the correct type.

pub unsafe fn assertFact_grade( &self, fact: &ProtocolObject<dyn NSObjectProtocol>, grade: c_float, )

Asserts a fact with the supplied membership grade.

This will cause the current rules to be evaluated, which may in turn assert or retract more facts or change the state of the system.

See: evaluate

Safety

fact should be of the correct type.

pub unsafe fn retractFact(&self, fact: &ProtocolObject<dyn NSObjectProtocol>)

Retracts a fact, setting its membership grade to 0, which also removes it from the fact set.

This will cause the current rules to be evaluated, which may in turn assert or retract more facts or change the state of the system.

This is short hand for calling retractFact:grade: with a grade of 1.0

See: retractFact:grade:

See: evaluate

Safety

fact should be of the correct type.

pub unsafe fn retractFact_grade( &self, fact: &ProtocolObject<dyn NSObjectProtocol>, grade: c_float, )

Retracts a fact, reducing its membership grade by the supplied grade. If this brings the grade to 0 it is also removed from the fact set.

This will cause the current rules to be evaluated, which may in turn assert or retract more facts or change the state of the system.

See: evaluate

Safety

fact should be of the correct type.

pub unsafe fn reset(&self)

Clears the agenda and executed sets and removes all facts currently in the system. It then fills the agenda with rules from the rule set, in salience order.

See: rules

See: facts

impl GKRuleSystem

Methods declared on superclass NSObject.

pub unsafe fn new() -> Retained<Self>

Methods from Deref<Target = NSObject>

pub fn doesNotRecognizeSelector(&self, sel: Sel) -> !

Handle messages the object doesn’t recognize.

See Apple’s documentation for details.

Methods from Deref<Target = AnyObject>

pub fn class(&self) -> &'static AnyClass

Dynamically find the class of this object.

Panics

May panic if the object is invalid (which may be the case for objects returned from unavailable init/new methods).

Example

Check that an instance of NSObject has the precise class NSObject.

use objc2::ClassType;
use objc2::runtime::NSObject;

let obj = NSObject::new();
assert_eq!(obj.class(), NSObject::class());

pub unsafe fn get_ivar<T>(&self, name: &str) -> &T

where T: Encode,

👎Deprecated: this is difficult to use correctly, use Ivar::load instead.

Use Ivar::load instead.

Safety

The object must have an instance variable with the given name, and it must be of type T.

See Ivar::load_ptr for details surrounding this.

pub fn downcast_ref<T>(&self) -> Option<&T>

where T: DowncastTarget,

Attempt to downcast the object to a class of type T.

This is the reference-variant. Use Retained::downcast if you want to convert a retained object to another type.

Mutable classes

Some classes have immutable and mutable variants, such as NSString and NSMutableString.

When some Objective-C API signature says it gives you an immutable class, it generally expects you to not mutate that, even though it may technically be mutable “under the hood”.

So using this method to convert a NSString to a NSMutableString, while not unsound, is generally frowned upon unless you created the string yourself, or the API explicitly documents the string to be mutable.

See Apple’s documentation on mutability and on isKindOfClass: for more details.

Generic classes

Objective-C generics are called “lightweight generics”, and that’s because they aren’t exposed in the runtime. This makes it impossible to safely downcast to generic collections, so this is disallowed by this method.

You can, however, safely downcast to generic collections where all the type-parameters are AnyObject.

Panics

This works internally by calling isKindOfClass:. That means that the object must have the instance method of that name, and an exception will be thrown (if CoreFoundation is linked) or the process will abort if that is not the case. In the vast majority of cases, you don’t need to worry about this, since both root objects NSObject and NSProxy implement this method.

Examples

Cast an NSString back and forth from NSObject.

use objc2::rc::Retained;
use objc2_foundation::{NSObject, NSString};

let obj: Retained<NSObject> = NSString::new().into_super();
let string = obj.downcast_ref::<NSString>().unwrap();
// Or with `downcast`, if we do not need the object afterwards
let string = obj.downcast::<NSString>().unwrap();

Try (and fail) to cast an NSObject to an NSString.

use objc2_foundation::{NSObject, NSString};

let obj = NSObject::new();
assert!(obj.downcast_ref::<NSString>().is_none());

Try to cast to an array of strings.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);
// This is invalid and doesn't type check.
let arr = arr.downcast_ref::<NSArray<NSString>>();

This fails to compile, since it would require enumerating over the array to ensure that each element is of the desired type, which is a performance pitfall.

Downcast when processing each element instead.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);

for elem in arr {
    if let Some(data) = elem.downcast_ref::<NSString>() {
        // handle `data`
    }
}

Trait Implementations

impl AsRef<AnyObject> for GKRuleSystem

fn as_ref(&self) -> &AnyObject

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<GKRuleSystem> for GKRuleSystem

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<NSObject> for GKRuleSystem

fn as_ref(&self) -> &NSObject

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<AnyObject> for GKRuleSystem

fn borrow(&self) -> &AnyObject

Immutably borrows from an owned value.

impl Borrow<NSObject> for GKRuleSystem

fn borrow(&self) -> &NSObject

Immutably borrows from an owned value.

impl ClassType for GKRuleSystem

const NAME: &'static str = "GKRuleSystem"

The name of the Objective-C class that this type represents.

type Super = NSObject

The superclass of this class.

type ThreadKind = <<GKRuleSystem as ClassType>::Super as ClassType>::ThreadKind

Whether the type can be used from any thread, or from only the main thread.

fn class() -> &'static AnyClass

Get a reference to the Objective-C class that this type represents.

fn as_super(&self) -> &Self::Super

Get an immutable reference to the superclass.

impl Debug for GKRuleSystem

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

Formats the value using the given formatter.

impl Deref for GKRuleSystem

type Target = NSObject

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Hash for GKRuleSystem

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

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 Message for GKRuleSystem

fn retain(&self) -> Retained<Self>

where Self: Sized,

Increment the reference count of the receiver.

impl NSObjectProtocol for GKRuleSystem

fn isEqual(&self, other: Option<&AnyObject>) -> bool

where Self: Sized + Message,

Check whether the object is equal to an arbitrary other object.

fn hash(&self) -> usize

where Self: Sized + Message,

An integer that can be used as a table address in a hash table structure.

fn isKindOfClass(&self, cls: &AnyClass) -> bool

where Self: Sized + Message,

Check if the object is an instance of the class, or one of its subclasses.

fn is_kind_of<T>(&self) -> bool

where T: ClassType, Self: Sized + Message,

👎Deprecated: use isKindOfClass directly, or cast your objects with AnyObject::downcast_ref

Check if the object is an instance of the class type, or one of its subclasses.

fn isMemberOfClass(&self, cls: &AnyClass) -> bool

where Self: Sized + Message,

Check if the object is an instance of a specific class, without checking subclasses.

fn respondsToSelector(&self, aSelector: Sel) -> bool

where Self: Sized + Message,

Check whether the object implements or inherits a method with the given selector.

fn conformsToProtocol(&self, aProtocol: &AnyProtocol) -> bool

where Self: Sized + Message,

Check whether the object conforms to a given protocol.

fn description(&self) -> Retained<NSObject>

where Self: Sized + Message,

A textual representation of the object.

fn debugDescription(&self) -> Retained<NSObject>

where Self: Sized + Message,

A textual representation of the object to use when debugging.

fn isProxy(&self) -> bool

where Self: Sized + Message,

Check whether the receiver is a subclass of the NSProxy root class instead of the usual NSObject.

fn retainCount(&self) -> usize

where Self: Sized + Message,

The reference count of the object.

impl PartialEq for GKRuleSystem

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

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

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 RefEncode for GKRuleSystem

const ENCODING_REF: Encoding = <NSObject as ::objc2::RefEncode>::ENCODING_REF

The Objective-C type-encoding for a reference of this type.

impl DowncastTarget for GKRuleSystem

impl Eq for GKRuleSystem