fxp_init 0.4.2

Initialization of configuration for fxp_videoclipper
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::config::Config;
use log::debug;
use std::env;

use crate::literals::FXP_VIDEOCLIPPER_SAMPLING_NUMBER;

enum SamplingSource {
    Env(usize),
    Config(usize),
    Default,
}

/// Determines the sampling number based on provided parameters and configuration.
///
/// # Parameters
/// - `multiple`: A boolean indicating whether multiple frames are being processed.
/// - `number`: An optional number provided via CLI argument.
/// - `config`: A reference to the configuration containing sampling settings.
///
/// # Returns
/// - `usize`: The resolved sampling number.
///
/// # Behavior
/// - **Multiple Frames (`multiple == true`):**
///   - If `number` is provided, its value is used.
///   - Otherwise, defaults to **10**.
/// - **Single Frame (`multiple == false`):**
///   - If `number` is provided, its value is used.
///   - Otherwise, a `Sampling` is created from `config`.
///     - If a valid sampling number exists in the configuration, that is used.
///     - Otherwise, the default of **1** is returned.
pub fn get_sampling_number(multiple: bool, number: Option<usize>, config: &Config) -> usize {
    if multiple {
        // For multiple frame sampling, CLI argument (if provided) takes priority,
        // and if absent, we use MultiSampling::new(config) to derive the number.
        number.unwrap_or_else(|| MultiSampling::default().number)
    } else {
        // For single frame sampling, CLI argument (if provided) takes priority,
        // otherwise we extract a number from the configuration using Sampling.
        number.unwrap_or_else(|| Sampling::new(config).number)
    }
}

/// A helper struct for single-frame sampling configuration.
/// It tries to derive the sampling number from the configuration.
#[derive(Debug)]
pub struct Sampling {
    pub number: usize,
}

/// A helper struct for multiple-frame sampling configuration.
/// It defaults the sampling number to 10.
#[derive(Debug)]
pub struct MultiSampling {
    pub number: usize,
}

impl Default for MultiSampling {
    /// The default sampling number for multiple frames is 10.
    fn default() -> Self {
        Self { number: 10 }
    }
}

impl Default for Sampling {
    /// The default sampling number is 1.
    fn default() -> Self {
        Self { number: 1 }
    }
}

impl Sampling {
    /// Creates a new `Sampling` instance based on configuration and environment settings.
    ///
    /// The function determines the sampling number through the following priority order:
    /// 1. The FXP_VIDEOCLIPPER_SAMPLING_NUMBER environment variable (if valid)
    /// 2. The `sampling_number` from the provided Config (if greater than 0)
    /// 3. Defaults to 1 if no valid sources are found
    ///
    /// # Parameters
    /// - `config`: A reference to the configuration containing sampling settings
    ///
    /// # Returns
    /// - `Self`: The newly created `Sampling` instance with the determined number
    ///
    /// # Notes
    /// - The environment variable must be a positive integer to be considered valid
    /// - The default sampling number is 1 when no valid sources are provided
    pub fn new(config: &Config) -> Self {
        // Determine the sampling number source using the enum.
        let sampling_source = match env::var(FXP_VIDEOCLIPPER_SAMPLING_NUMBER) {
            Ok(env_value) => match env_value.parse::<usize>() {
                Ok(val) if val > 0 => SamplingSource::Env(val),
                _ => {
                    if config.sampling_number > 0 {
                        SamplingSource::Config(config.sampling_number)
                    } else {
                        SamplingSource::Default
                    }
                }
            },
            Err(_) => {
                if config.sampling_number > 0 {
                    SamplingSource::Config(config.sampling_number)
                } else {
                    SamplingSource::Default
                }
            }
        };

        // Use a match statement to choose the appropriate branch based on the source.
        match sampling_source {
            SamplingSource::Env(num) => {
                debug!("Using sampling number from FXP_VIDEOCLIPPER_SAMPLING_NUMBER environment variable: {}", num);
                Self { number: num }
            }
            SamplingSource::Config(num) => {
                debug!("Using sampling number from configuration file: {}", num);
                Self { number: num }
            }
            SamplingSource::Default => {
                debug!("No valid sampling number provided; defaulting to Sampling::default().");
                Self::default()
            }
        }
    }
}