Struct vrp_core::models::ConstraintViolation

pub struct ConstraintViolation {
    pub code: ViolationCode,
    pub stopped: bool,
}

Specifies a result of hard route constraint check.

Fields

code: ViolationCode

Violation code which is used as marker of specific constraint violated.

stopped: bool

True if further insertions should not be attempted.

Implementations

impl ConstraintViolation

pub fn fail(code: ViolationCode) -> Option<Self>

A constraint violation failure with stopped set to true.

Examples found in repository

examples/custom_constraint.rs (line 41)

    fn evaluate(&self, move_ctx: &MoveContext<'_>) -> Option<ConstraintViolation> {
        match move_ctx {
            // matching job to route is evaluated before activity matching, so use it to improve search procedure
            MoveContext::Route { route_ctx, job, .. } => {
                let hardware_vehicle = route_ctx.route().actor.vehicle.dimens.get_vehicle_hardware();
                let hardware_job = job.dimens().get_job_hardware();

                match (hardware_job, hardware_vehicle) {
                    (None, _) => None,
                    (Some(hw_job), Some(hw_vehicle)) if hw_vehicle.contains(hw_job) => None,
                    _ => ConstraintViolation::fail(self.code),
                }
            }
            // matching activity to route is called for every possible insertion point in the tour
            // we don't need it here as hard constraint can be validated on route-job level
            MoveContext::Activity { .. } => None,
        }
    }

pub fn skip(code: ViolationCode) -> Option<Self>

A constraint violation failure with stopped set to false.

pub fn success() -> Option<Self>

No constraint violation.

Trait Implementations

impl Clone for ConstraintViolation

fn clone(&self) -> ConstraintViolation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ConstraintViolation

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

Formats the value using the given formatter.

impl PartialEq for ConstraintViolation

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ConstraintViolation

impl StructuralPartialEq for ConstraintViolation