ommui_data 0.12.3

#[cfg(feature = "reqwest")]
use reqwest;

use snafu::Backtrace;
use {ommui_file_loading, uuid};

#[derive(Debug, Snafu)]
#[snafu(visibility(pub(crate)))]
pub enum Error {
    #[snafu(display("IO error: {:?}", source))]
    Io {
        source: std::io::Error,
        backtrace: Backtrace,
    },

    #[snafu(display("Serde error: {:?}", source))]
    Serde {
        source: serde_json::Error,
        backtrace: Backtrace,
    },

    #[snafu(display("Item '{}' of kind '{}' not found", id, kind))]
    NotFound {
        kind: &'static str,
        id: String,
        backtrace: Backtrace,
    },

    #[snafu(display("Error parsing uuid from {:?}: {}", raw, source))]
    ParseUuid {
        raw: String,
        source: uuid::parser::ParseError,
        backtrace: Backtrace,
    },

    #[cfg(feature = "reqwest")]
    #[snafu(display("Error from reqwest: {}", source))]
    Reqwest {
        source: reqwest::Error,
        backtrace: Backtrace,
    },

    #[snafu(display("Error reading response from {}: {}", url, source))]
    ReadResponse {
        url: String,
        source: std::io::Error,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Error parsing integer value from {:?}: {}",
        raw,
        source
    ))]
    ParseInt {
        raw: String,
        source: std::num::ParseIntError,
        backtrace: Backtrace,
    },

    #[snafu(display("{}", source))]
    #[snafu(backtrace(delegate))]
    OmmuiFileLoading { source: ommui_file_loading::Error },

    #[snafu(display(
        "Parent profile {} has sampling id {:?}, \
         this profile has sampling id {:?}",
        parent_profile,
        parent_sampling_id,
        sampling_id
    ))]
    ProfileParentDifferentSamplingId {
        parent_profile: uuid::Uuid,
        parent_sampling_id: String,
        sampling_id: String,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Sampling {:?} has {} parameters, profile defines {} parameters",
        sampling_id,
        sampling_parameter_count,
        profile_parameter_count
    ))]
    ProfileParameterCountMismatchToSampling {
        profile_parameter_count: usize,
        sampling_parameter_count: usize,
        sampling_id: String,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Sampling {:?} has no parameter with id {:?}",
        sampling_id,
        parameter_id
    ))]
    SamplingParameterNotFound {
        sampling_id: String,
        parameter_id: String,
        backtrace: Backtrace,
    },

    #[snafu(display(
            "Parameter {:?} value {} of sampling {:?} is out of range ({}, {})",
            parameter_id, value, sampling_id, minimum, maximum))]
    ProfileNumericParameterValueOutOfRange {
        sampling_id: String,
        parameter_id: String,
        minimum: f64,
        maximum: f64,
        value: f64,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Parameter {:?} representation {:?} of sampling {:?} \
         not in list of allowed representations {:?}",
        parameter_id,
        representation,
        sampling_id,
        allowed_representations
    ))]
    ParameterRepresentationNotAllowed {
        parameter_id: String,
        representation: String,
        sampling_id: String,
        allowed_representations: Vec<String>,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Result {:?} representation {:?} of sampling {:?} \
         not in list of allowed representations {:?}",
        result_id,
        representation,
        sampling_id,
        allowed_representations
    ))]
    ResultRepresentationNotAllowed {
        result_id: String,
        representation: String,
        sampling_id: String,
        allowed_representations: Vec<String>,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Parameter {:?} enumeration value {:?} of sampling {:?} \
         not in list of allowed values {:?}",
        parameter_id,
        enumeration_value,
        sampling_id,
        allowed_enumeration_values
    ))]
    EnumerationValueNotFound {
        parameter_id: String,
        enumeration_value: String,
        sampling_id: String,
        allowed_enumeration_values: Vec<String>,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Parameter {:?} of sampling {:?} requires type {:?}, \
         received type {:?}",
        parameter_id,
        sampling_id,
        required,
        found
    ))]
    ProfileParameterTypeMismatch {
        parameter_id: String,
        sampling_id: String,
        required: crate::samplic::ParameterType,
        found: crate::samplic::ParameterType,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Sampling {:?} has no result with id {:?}",
        sampling_id,
        result_id
    ))]
    SamplingResultNotFound {
        sampling_id: String,
        result_id: String,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Sampling {:?} has no curve with id {:?}",
        sampling_id,
        curve_id
    ))]
    SamplingCurveNotFound {
        sampling_id: String,
        curve_id: String,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Curve axis unit representation {:?} not allowed in \
         sampling {:?} curve {:?} axis {:?}. \
         Allowed: {:?}",
        representation,
        sampling_id,
        curve_id,
        axis,
        allowed_representations
    ))]
    AxisUnitRepresentationNotAllowed {
        sampling_id: String,
        curve_id: String,
        axis: String,
        representation: String,
        allowed_representations: Vec<String>,
        backtrace: Backtrace,
    },

    #[snafu(display(
        "Expected coordinate system {:?}, found {:?} \
         for sampling {:?} curve {:?}.",
        expected,
        found,
        sampling_id,
        curve_id
    ))]
    CoordinateSystemMismatch {
        sampling_id: String,
        curve_id: String,
        found: crate::samplic::CoordinateSystem,
        expected: crate::samplic::CoordinateSystem,
        backtrace: Backtrace,
    },

    #[snafu(display("Invalid file path {:?}", file_path))]
    InvalidFilePath { file_path: String },
}