pak-db 0.2.2

A read-only database format designed for speed, ease of use and data sharing.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use ordermap::OrderSet;
use serde::{Deserialize, Serialize};

use crate::{error::PakResult, group::{DeserializeGroup}, query::PakQueryExpression};

//==============================================================================================
//        PakPointer
//==============================================================================================

/// A pointer that points to a specific location in the pak file. It comes in two flavors, typed and untyped. This pointer is typically offset by the size of the header.
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Hash)]
pub enum PakPointer {
    Typed(PakTypedPointer),
    Untyped(PakUntypedPointer),
}

impl PakPointer {
    pub fn new_typed<T>(offset : u64, size : u64) -> Self {
        Self::Typed(PakTypedPointer::new(offset, size, std::any::type_name::<T>()))
    }

    pub fn new_untyped(offset : u64, size : u64) -> Self {
        Self::Untyped(PakUntypedPointer::new(offset, size))
    }
    
    pub fn offset(&self) -> u64 {
        match self {
            Self::Typed(ptr) => ptr.offset,
            Self::Untyped(ptr) => ptr.offset,
        }
    }
    
    pub fn size(&self) -> u64 {
        match self {
            Self::Typed(ptr) => ptr.size,
            Self::Untyped(ptr) => ptr.size,
        }
    }
    
    pub fn type_name(&self) -> &str {
        match self {
            Self::Typed(ptr) => &ptr.type_name,
            Self::Untyped(_) => "Untyped",
        }
    }
    
    pub fn as_untyped(&self) -> PakUntypedPointer {
        match self {
            Self::Typed(ptr) => PakUntypedPointer::new(ptr.offset, ptr.size),
            Self::Untyped(ptr) => *ptr,
        }
    }
    
    pub fn into_typed<T>(self) -> PakTypedPointer {
        match self {
            Self::Typed(ptr) => ptr,
            Self::Untyped(ptr) => PakTypedPointer::new(ptr.offset, ptr.size, std::any::type_name::<T>()),
        }
    }
    
    pub fn type_is_match<T>(&self) -> bool {
        match self {
            Self::Typed(ptr) => ptr.type_name == std::any::type_name::<T>(),
            Self::Untyped(_) => true,
        }
    }
    
    pub fn drop_type(&mut self) {
        let pointer = PakPointer::Untyped(PakUntypedPointer { offset: self.offset(), size: self.size() });
        *self = pointer
    }
}

impl Clone for PakPointer {
    fn clone(&self) -> Self {
        match self {
            Self::Typed(ptr) => Self::Typed(ptr.clone()),
            Self::Untyped(ptr) => Self::Untyped(*ptr),
        }
    }
}

impl <T> PakQueryExpression<T> for PakPointer where T : DeserializeGroup {
    fn execute(&self, _pak : &crate::Pak) -> PakResult<OrderSet<PakPointer>> {
        Ok(OrderSet::from([self.clone()]))
    }
}

impl From<PakUntypedPointer> for PakPointer {
    fn from(value: PakUntypedPointer) -> Self {
        PakPointer::Untyped(value)
    }
}

impl From<PakTypedPointer> for PakPointer {
    fn from(value: PakTypedPointer) -> Self {
        PakPointer::Typed(value)
    }
}

//==============================================================================================
//        PakTypedPointer
//==============================================================================================

/// A typed pointer. This tells you what rust type is stored at the location pointed to. You can check it with a type at runtime to fail requests that have a type mismatch.
#[derive(Clone, Debug, PartialEq, Eq, Default, Serialize, Deserialize, Hash)]
pub struct PakTypedPointer {
    offset : u64,
    size : u64,
    type_name : String,
}

impl PakTypedPointer {
    pub fn new(offset : u64, size : u64, type_name : &str) -> Self {
        Self { offset, size, type_name : type_name.to_string() }
    }
    
    pub fn into_pointer(self) -> PakPointer {
        PakPointer::Typed(self)
    }
}

//==============================================================================================
//        PakUntypedPointer
//==============================================================================================

/// An untyped pointer. This tells you the offset and size of the data at the location pointed to. This is useful if you always know the type of the data at the location pointed to.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize, Hash)]
pub struct PakUntypedPointer {
    offset : u64,
    size : u64,
}

impl PakUntypedPointer {
    pub fn new(offset : u64, size : u64) -> Self {
        Self { offset, size }
    }
    
    pub fn as_pointer(&self) -> PakPointer {
        PakPointer::Untyped(*self)
    }
}