pub const SCRAP_STUFF_RECORD_SIZE: usize = 16;
pub const NO_TYPE_ERR: i16 = -102;
pub const MEM_FULL_ERR: i16 = -108;
pub const NO_SCRAP_ERR: i16 = -100;
pub const PARAM_ERR: i16 = -50;
pub const NO_ERR: i16 = 0;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ScrapStuffRecord {
pub scrap_size: u32,
pub scrap_handle: u32,
pub scrap_count: u16,
pub scrap_state: i16,
pub scrap_name: u32,
}
#[inline]
pub fn evaluate_scrap_stuff_record(
serialized_size: u32,
scrap_handle: u32,
count: u16,
in_memory: bool,
) -> ScrapStuffRecord {
ScrapStuffRecord {
scrap_size: serialized_size,
scrap_handle: if in_memory { scrap_handle } else { 0 },
scrap_count: count,
scrap_state: if in_memory { 1 } else { 0 },
scrap_name: 0,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct GetScrapParameters {
pub destination_handle: u32,
pub flavor_type: [u8; 4],
pub offset_ptr: u32,
}
impl GetScrapParameters {
#[allow(dead_code)]
#[inline]
pub const fn is_query_only(&self) -> bool {
self.destination_handle == 0
}
}
#[inline]
pub fn evaluate_get_scrap_parameters(
destination_handle: u32,
flavor_type: [u8; 4],
offset_ptr: u32,
) -> GetScrapParameters {
GetScrapParameters {
destination_handle,
flavor_type,
offset_ptr,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PutScrapParameters {
pub length: i32,
pub flavor_type: [u8; 4],
pub source_ptr: u32,
}
impl PutScrapParameters {
#[inline]
pub const fn is_valid(&self) -> bool {
self.length > 0 && self.source_ptr != 0
}
#[allow(dead_code)]
#[inline]
pub const fn data_length(&self) -> usize {
if self.length > 0 {
self.length as usize
} else {
0
}
}
}
#[inline]
pub fn evaluate_put_scrap_parameters(
length: i32,
flavor_type: [u8; 4],
source_ptr: u32,
) -> PutScrapParameters {
PutScrapParameters {
length,
flavor_type,
source_ptr,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ZeroScrapAction;
#[inline]
pub fn evaluate_zero_scrap() -> ZeroScrapAction {
ZeroScrapAction
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LoadScrapAction;
#[inline]
pub fn evaluate_load_scrap() -> LoadScrapAction {
LoadScrapAction
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct UnloadScrapAction;
#[inline]
pub fn evaluate_unload_scrap() -> UnloadScrapAction {
UnloadScrapAction
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn scrap_manager_evaluation() {
assert_eq!(SCRAP_STUFF_RECORD_SIZE, 16);
assert_eq!(NO_TYPE_ERR, -102);
assert_eq!(MEM_FULL_ERR, -108);
assert_eq!(NO_SCRAP_ERR, -100);
assert_eq!(PARAM_ERR, -50);
assert_eq!(NO_ERR, 0);
let in_mem = evaluate_scrap_stuff_record(42, 0x1234, 3, true);
assert_eq!(in_mem.scrap_size, 42);
assert_eq!(in_mem.scrap_handle, 0x1234);
assert_eq!(in_mem.scrap_count, 3);
assert_eq!(in_mem.scrap_state, 1);
assert_eq!(in_mem.scrap_name, 0);
let on_disk = evaluate_scrap_stuff_record(100, 0x1234, 4, false);
assert_eq!(on_disk.scrap_size, 100);
assert_eq!(on_disk.scrap_handle, 0);
assert_eq!(on_disk.scrap_count, 4);
assert_eq!(on_disk.scrap_state, 0);
assert_eq!(on_disk.scrap_name, 0);
let get_query = evaluate_get_scrap_parameters(0, *b"TEXT", 0x5000);
assert_eq!(get_query.destination_handle, 0);
assert_eq!(get_query.flavor_type, *b"TEXT");
assert_eq!(get_query.offset_ptr, 0x5000);
assert!(get_query.is_query_only());
let get_copy = evaluate_get_scrap_parameters(0x6000, *b"PICT", 0x5004);
assert_eq!(get_copy.destination_handle, 0x6000);
assert_eq!(get_copy.flavor_type, *b"PICT");
assert_eq!(get_copy.offset_ptr, 0x5004);
assert!(!get_copy.is_query_only());
let put_valid = evaluate_put_scrap_parameters(12, *b"TEXT", 0x7000);
assert_eq!(put_valid.length, 12);
assert_eq!(put_valid.flavor_type, *b"TEXT");
assert_eq!(put_valid.source_ptr, 0x7000);
assert!(put_valid.is_valid());
assert_eq!(put_valid.data_length(), 12);
let put_zero_len = evaluate_put_scrap_parameters(0, *b"TEXT", 0x7000);
assert!(!put_zero_len.is_valid());
assert_eq!(put_zero_len.data_length(), 0);
let put_null_ptr = evaluate_put_scrap_parameters(12, *b"TEXT", 0);
assert!(!put_null_ptr.is_valid());
let put_neg_len = evaluate_put_scrap_parameters(-5, *b"TEXT", 0x7000);
assert!(!put_neg_len.is_valid());
assert_eq!(put_neg_len.data_length(), 0);
assert_eq!(evaluate_zero_scrap(), ZeroScrapAction);
assert_eq!(evaluate_load_scrap(), LoadScrapAction);
assert_eq!(evaluate_unload_scrap(), UnloadScrapAction);
}
}