ferretro/ferretro_components/src/provided/stdlib/logs.rs

use crate::prelude::*;

use ferretro_base::retro::ffi::{Message, Language};

use std::os::raw::c_uint;
use std::path::PathBuf;

/// Write's the core's own log statements to stderr.
pub struct StderrLogComponent {
    /// May be set to add a prefix to each logged line.
    pub prefix: String,
    /// The most verbose log level that should be printed.
    pub level: ferretro_base::retro::ffi::LogLevel,
}

impl Default for StderrLogComponent {
    fn default() -> Self {
        StderrLogComponent {
            prefix: String::new(),
            level: ferretro_base::retro::ffi::LogLevel::Info,
        }
    }
}

impl RetroComponent for StderrLogComponent {}

impl RetroCallbacks for StderrLogComponent {
    fn log_print(&mut self, level: ferretro_base::retro::ffi::LogLevel, msg: &str) {
        if level >= self.level {
            eprint!("{}[{:?}] {}", self.prefix, level, msg);
        }
    }
}

/// Writes all the input descriptors, variables, and subsystem information to stderr as they are
/// provided by the core.
#[derive(Default)]
pub struct StderrSysInfoLogComponent {
    /// May be set to add a prefix to each logged line.
    pub prefix: String,
}

impl RetroComponent for StderrSysInfoLogComponent {}

impl RetroCallbacks for StderrSysInfoLogComponent {
    fn set_input_descriptors(&mut self, descriptors: &[InputDescriptor2]) -> Option<bool> {
        for id in descriptors {
            eprintln!("{}{:?}", self.prefix, id);
        }
        Some(true)
    }

    fn set_variables(&mut self, variables: &[Variable2]) -> Option<bool> {
        for v in variables {
            eprintln!("{}{:?}", self.prefix, v);
        }
        Some(true)
    }

    fn set_subsystem_info(&mut self, subsystem_info: &[SubsystemInfo2]) -> Option<bool> {
        for s in subsystem_info {
            eprintln!("{}{:?}", self.prefix, s);
        }
        Some(true)
    }
}

/// Trace-logs every callback call made and their arguments to stderr.
#[derive(Default)]
pub struct StderrCallTraceComponent {
    /// May be set to add a prefix to each logged line.
    pub prefix: String,
}

impl RetroComponent for StderrCallTraceComponent {}

impl RetroCallbacks for StderrCallTraceComponent {
    fn video_refresh(&mut self, frame: &VideoFrame) {
        eprintln!("{}video_refresh({:?})", self.prefix, frame);
    }
    fn audio_samples(&mut self, stereo_pcm: &[i16]) -> usize {
        eprintln!("{}audio_samples([i16; {}])", self.prefix, stereo_pcm.len());
        0
    }
    fn input_poll(&mut self) {
        eprintln!("{}input_poll()", self.prefix);
    }
    fn input_state(&mut self, port: u32, device: InputDeviceId, index: InputIndex) -> i16 {
        eprintln!("{}input_state({}, {:?}, {:?})", self.prefix, port, device, index);
        0
    }
    fn set_rotation(&mut self, rotation: EnvRotation) -> Option<bool> {
        eprintln!("{}set_rotation({:?})", self.prefix, rotation);
        None
    }
    fn get_overscan(&mut self) -> Option<bool> {
        eprintln!("{}get_overscan()", self.prefix);
        None
    }
    fn set_message(&mut self, message: &Message) -> Option<bool> {
        eprintln!("{}set_message({:?})", self.prefix, message);
        None
    }
    fn shutdown(&mut self) -> Option<bool> {
        eprintln!("{}shutdown()", self.prefix);
        None
    }
    fn set_performance_level(&mut self, level: c_uint) -> Option<bool> {
        eprintln!("{}set_performance_level({})", self.prefix, level);
        None
    }
    fn get_system_directory(&mut self) -> Option<PathBuf> {
        eprintln!("{}get_system_directory()", self.prefix);
        None
    }
    fn set_pixel_format(&mut self, format: PixelFormat) -> Option<bool> {
        eprintln!("{}set_pixel_format({:?})", self.prefix, format);
        None
    }
    fn set_input_descriptors(&mut self, input_descriptors: &[InputDescriptor2]) -> Option<bool> {
        eprintln!("{}set_input_descriptors(vec![InputDescriptor2; {}])", self.prefix, input_descriptors.len());
        None
    }
    fn set_hw_render(&mut self, hw_render_callback: &HwRenderCallback) -> Option<bool> {
        eprintln!("{}set_hw_render({:?})", self.prefix, hw_render_callback);
        None
    }
    fn get_variable(&mut self, key: &str) -> Option<String> {
        eprintln!("{}get_variable({:?})", self.prefix, key);
        None
    }
    fn set_variables(&mut self, variables: &[Variable2]) -> Option<bool> {
        eprintln!("{}set_variables(vec![Variable2; {}])", self.prefix, variables.len());
        None
    }
    fn get_variable_update(&mut self) -> Option<bool> {
        eprintln!("{}get_variable_update()", self.prefix);
        None
    }
    fn set_support_no_game(&mut self, supports_no_game: bool) -> Option<bool> {
        eprintln!("{}set_support_no_game({})", self.prefix, supports_no_game);
        None
    }
    fn get_libretro_path(&mut self) -> Option<PathBuf> {
        eprintln!("{}get_libretro_path()", self.prefix);
        None
    }
    fn get_input_device_capabilities(&mut self) -> Option<u64> {
        eprintln!("{}get_input_device_capabilities()", self.prefix);
        None
    }
    fn get_core_assets_directory(&mut self) -> Option<PathBuf> {
        eprintln!("{}get_core_assets_directory()", self.prefix);
        None
    }
    fn get_save_directory(&mut self) -> Option<PathBuf> {
        eprintln!("{}get_save_directory()", self.prefix);
        None
    }
    fn set_system_av_info(&mut self, system_av_info: &SystemAvInfo) -> Option<bool> {
        eprintln!("{}set_system_av_info({:?})", self.prefix, system_av_info);
        None
    }
    fn set_subsystem_info(&mut self, subsystem_info: &[SubsystemInfo2]) -> Option<bool> {
        eprintln!("{}set_subsystem_info(vec![SubsystemInfo2; {}])", self.prefix, subsystem_info.len());
        None
    }
    fn set_controller_info(&mut self, controller_info: &[ControllerDescription2]) -> Option<bool> {
        eprintln!("{}set_controller_info(vec![ControllerDescription2; {}])", self.prefix, controller_info.len());
        None
    }
    fn set_memory_maps(&mut self, memory_map: &MemoryMap) -> Option<bool> {
        eprintln!("{}set_memory_maps({:?})", self.prefix, memory_map);
        None
    }
    fn set_geometry(&mut self, game_geometry: &GameGeometry) -> Option<bool> {
        eprintln!("{}set_geometry({:?})", self.prefix, game_geometry);
        None
    }
    fn get_username(&mut self) -> Option<String> {
        eprintln!("{}get_username()", self.prefix);
        None
    }
    fn get_language(&mut self) -> Option<Language> {
        eprintln!("{}get_language()", self.prefix);
        None
    }
    fn get_camera_interface(&mut self, width: c_uint, height: c_uint, cap_raw_fb: bool, cap_gl_tex: bool) -> Option<bool> {
        eprintln!("{}get_camera_interface(width={}, height={}, fb={}, gl={})", self.prefix, width, height, cap_raw_fb, cap_gl_tex);
        None
    }
    fn camera_start(&mut self) -> Option<bool> {
        eprintln!("{}camera_start()", self.prefix);
        None
    }
    fn camera_stop(&mut self) -> Option<()> {
        eprintln!("{}camera_stop()", self.prefix);
        None
    }
    fn hw_get_current_framebuffer(&mut self) -> Option<usize> {
        eprintln!("{}hw_get_current_framebuffer()", self.prefix);
        None
    }
    fn hw_get_proc_address(&mut self, sym: &str) -> Option<*const ()> {
        eprintln!("{}hw_get_proc_address({:?})", self.prefix, sym);
        None
    }
    // TODO: etc...
}