Struct RatingScale 

pub struct RatingScale {
    pub min: f64,
    pub max: f64,
    pub allow_ties: bool,
    pub step: Option<f64>,
}

Rating scale configuration for numeric ratings

Defines the valid range and behavior for user ratings.

Fields

min: f64

Minimum rating value

max: f64

Maximum rating value

allow_ties: bool

Whether ties are allowed (for pairwise comparisons)

step: Option<f64>

Optional step size (e.g., 0.5 for half-star ratings)

Implementations

impl RatingScale

pub fn new(min: f64, max: f64) -> Self

Create a new rating scale

pub fn one_to_ten() -> Self

Standard 1-10 rating scale

pub fn one_to_five() -> Self

Standard 1-5 rating scale (5-star rating)

pub fn binary() -> Self

Binary like/dislike scale

pub fn with_ties(self, allow: bool) -> Self

Set whether ties are allowed

pub fn with_step(self, step: f64) -> Self

Set the step size for discrete ratings

pub fn validate(&self, rating: f64) -> bool

Validate a rating against this scale

pub fn clamp(&self, rating: f64) -> f64

Clamp a rating to the valid range

pub fn normalize(&self, rating: f64) -> f64

Normalize a rating to [0, 1] range

pub fn denormalize(&self, normalized: f64) -> f64

Denormalize a [0, 1] value to this scale

Trait Implementations

impl Clone for RatingScale

fn clone(&self) -> RatingScale

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RatingScale

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

Formats the value using the given formatter.

impl Default for RatingScale

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RatingScale

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RatingScale

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

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 RatingScale