use std::fmt;
use std::sync::Arc;
use crate::plugin::PluginOptions;
use crate::{Error, MemoryInput, MemoryOutput, Result};
#[derive(Clone)]
pub enum SwitcherInput {
Native(PluginOptions),
Memory(Arc<MemoryInput>),
}
impl fmt::Debug for SwitcherInput {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Native(value) => formatter.debug_tuple("Native").field(value).finish(),
Self::Memory(_) => formatter.debug_tuple("Memory").finish(),
}
}
}
#[derive(Clone)]
pub enum SwitcherOutput {
Native(PluginOptions),
Memory(Arc<MemoryOutput>),
}
impl fmt::Debug for SwitcherOutput {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Native(value) => formatter.debug_tuple("Native").field(value).finish(),
Self::Memory(_) => formatter.debug_tuple("Memory").finish(),
}
}
}
#[derive(Debug, Clone)]
pub struct InputSwitcherConfig {
pub fast_switch: bool,
pub delayed_switch: bool,
pub terminate: bool,
pub reuse_port: bool,
pub first_input: i64,
pub primary_input: i64,
pub cycle_count: i64,
pub buffered_packets: i64,
pub max_input_packets: i64,
pub max_output_packets: i64,
pub sock_buffer: i64,
pub remote_server_port: i64,
pub receive_timeout: i64,
pub event_command: String,
pub event_udp_address: String,
pub event_udp_port: i64,
pub event_local_address: String,
pub event_ttl: i64,
pub application_name: String,
pub inputs: Vec<SwitcherInput>,
pub output: Option<SwitcherOutput>,
}
impl Default for InputSwitcherConfig {
fn default() -> Self {
Self {
fast_switch: false,
delayed_switch: false,
terminate: false,
reuse_port: false,
first_input: 0,
primary_input: -1,
cycle_count: 1,
buffered_packets: 0,
max_input_packets: 0,
max_output_packets: 0,
sock_buffer: 0,
remote_server_port: 0,
receive_timeout: 0,
event_command: String::new(),
event_udp_address: String::new(),
event_udp_port: 0,
event_local_address: String::new(),
event_ttl: 0,
application_name: String::new(),
inputs: Vec::new(),
output: None,
}
}
}
pub(crate) fn validate(config: &InputSwitcherConfig) -> Result<()> {
if config.inputs.is_empty() {
return Err(Error::InvalidArgument {
field: "inputs",
message: "must not be empty".to_owned(),
});
}
for value in [
config.first_input,
config.primary_input,
config.cycle_count,
config.buffered_packets,
config.max_input_packets,
config.max_output_packets,
config.sock_buffer,
config.remote_server_port,
config.receive_timeout,
config.event_udp_port,
config.event_ttl,
] {
if !fits_native_long(value) {
return Err(Error::InvalidArgument {
field: "switcher option",
message: "does not fit the native long type".to_owned(),
});
}
}
for input in &config.inputs {
if let SwitcherInput::Native(plugin) = input {
plugin.validate_not_memory("inputs")?;
}
}
if let Some(SwitcherOutput::Native(plugin)) = &config.output {
plugin.validate_not_memory("output")?;
}
Ok(())
}
fn fits_native_long(value: i64) -> bool {
size_of::<std::ffi::c_long>() != size_of::<i32>()
|| (i64::from(i32::MIN)..=i64::from(i32::MAX)).contains(&value)
}