Struct Context

pub struct Context { /* private fields */ }

Context is a collection of attributes that can be referenced in flag evaluations and analytics events. These attributes are described by one or more Kinds.

For example, a context might represent the user of a service, the description of an organization, IoT device metadata, or any combination of those at once.

To create a context of a single kind, such as a user, you may use crate::ContextBuilder.

To create a context with multiple kinds, use crate::MultiContextBuilder.

Implementations

impl Context

pub fn is_multi(&self) -> bool

Returns true if the context is a multi-context.

pub fn get_value(&self, reference: &Reference) -> Option<AttributeValue>

Looks up the value of any attribute of the context, or a value contained within an attribute, based on the given reference.

This lookup includes only attributes that are addressable in evaluations– not metadata such as private attributes.

This method implements the same behavior that the SDK uses to resolve attribute references during a flag evaluation. In a single context, the reference can represent a simple attribute name– either a built-in one like “name” or “key”, or a custom attribute that was set by methods like crate::ContextBuilder::set_string– or, it can be a slash-delimited path.

For a multi-context, the only supported attribute name is “kind”. Use Context::as_kind to inspect a context for a particular Kind and then get its attributes.

pub fn key(&self) -> &str

Returns the “key” attribute.

For a single context, this value is set by the crate::ContextBuilder::new or crate::ContextBuilder::key methods.

For a multi-context, there is no single key, so Context::key returns an empty string; use Context::as_kind to inspect a context for a particular kind and call Context::key on it.

pub fn canonical_key(&self) -> &str

Returns the canonical key.

1. For a single context of kind “user”, the canonical key is equivalent to the key.
2. For other kinds of single contexts, the canonical key is “kind:key”.
3. For a multi-context, the canonical key is the concatenation of its constituent contexts’ canonical keys with : according to (2) (including kind “user”).

pub fn kind(&self) -> &Kind

Returns the “kind” attribute.

pub fn as_kind(&self, kind: &Kind) -> Option<&Context>

If the specified kind exists within the context, returns a reference to it. Otherwise, returns None.

pub fn context_keys(&self) -> HashMap<&Kind, &str>

Returns a map of all (kind, key) pairs contained in this context.

pub fn kinds(&self) -> Vec<&Kind>

Returns a list of all kinds represented by this context.

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Context

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Context

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Context

fn eq(&self, other: &Context) -> 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 Serialize for Context

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 Context