Enum Condition 

pub enum Condition {
    ModelName(String),
    ModelPrefix(String),
    UserRegion(String),
    RequestSize(u32),
    TokenCount(u32),
    TimeOfDay {
        start: u8,
        end: u8,
    },
    Custom(String),
}

Conditions for conditional routing.

Defines various conditions that can be used to determine routing decisions.

Variants

ModelName(String)

Route based on exact model name match

ModelPrefix(String)

Route based on model name prefix

UserRegion(String)

Route based on user’s geographic region

RequestSize(u32)

Route based on request size in bytes

TokenCount(u32)

Route based on estimated token count

TimeOfDay

Route based on time of day (24-hour format)

Fields

start: u8

end: u8

Custom(String)

Custom condition for user-defined logic

Implementations

impl Condition

pub fn matches(&self, context: &RoutingContext) -> bool

Check if this condition matches the given routing context.

Arguments

• context - The routing context to check against

Returns

Returns true if the condition matches the context, false otherwise.

Examples

use ultrafast_models_sdk::routing::{Condition, RoutingContext};
use std::collections::HashMap;

let context = RoutingContext {
    model: Some("gpt-4".to_string()),
    user_region: Some("us-east-1".to_string()),
    request_size: 1000,
    estimated_tokens: 500,
    user_id: Some("user123".to_string()),
    metadata: HashMap::new(),
};

let model_condition = Condition::ModelName("gpt-4".to_string());
assert!(model_condition.matches(&context));

let region_condition = Condition::UserRegion("us-east-1".to_string());
assert!(region_condition.matches(&context));

Trait Implementations

impl Clone for Condition

fn clone(&self) -> Condition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Condition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Condition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Condition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.