wip

Author: JAD3N

steamkit-vdf/Cargo.toml

@@ -13,6 +13,7 @@ This crate is designed to be a bunch of tools for interacting with the Steam API
 
 [dependencies]
 thiserror = "2.0"
+cfg-if = "1.0"
 
 [dependencies.regex-lite]
 version = "0.1"
@@ -26,3 +27,4 @@ optional = true
 default = ["regex"]
 regex = ["dep:regex"]
 regex-lite = ["dep:regex-lite"]
+precision = []

steamkit-vdf/src/entry.rs

@@ -4,4 +4,9 @@ pub type Result<T> = std::result::Result<T, Error>;
 pub enum Error {
     #[error("Failed to parse input")]
     Parse,
+    #[error("Only {variant} can be converted to {output_type}")]
+    InvalidConversion {
+        variant: &'static str,
+        output_type: &'static str,
+    },
 }

steamkit-vdf/src/error.rs

@@ -1,3 +1,7 @@
-pub mod entry;
-pub mod error;
-pub mod parser;
+mod error;
+mod parser;
+mod types;
+
+pub use error::*;
+pub use parser::*;
+pub use types::*;

steamkit-vdf/src/lib.rs

@@ -1,4 +1,4 @@
-use crate::{entry::Entry, error::Error};
+use std::io::{BufReader, Cursor, Read};
 
 #[cfg(all(feature = "regex", feature = "regex-lite"))]
 compile_error!("Features 'regex' and 'regex-lite' cannot be enabled at the same time.");
@@ -7,6 +7,8 @@ use regex::Regex;
 #[cfg(feature = "regex-lite")]
 use regex_lite::Regex;
 
+use crate::{Group, Result};
+
 thread_local! {
     static INT_REGEX: Regex = Regex::new(r"^\-?\d+$").unwrap();
     static FLOAT_REGEX: Regex = Regex::new(r"\-?\d+\.\d+$").unwrap();
@@ -19,6 +21,14 @@ pub struct Options {
     pub conditionals: Option<Vec<String>>,
 }
 
-pub fn parse(input: &str, options: &Options) -> Result<Entry, Error> {
-    todo!()
+pub fn from_str(input: &str, options: &Options) -> Result<Group> {
+    let reader = Cursor::new(input.as_bytes());
+    from_reader(reader, options)
+}
+
+pub fn from_reader<R: Read>(input: R, options: &Options) -> Result<Group> {
+    let mut reader = BufReader::new(input);
+    let mut entries = vec![];
+
+    Ok(Group { entries })
 }

steamkit-vdf/src/parser.rs

@@ -0,0 +1,216 @@
+use crate::{Error, Result};
+
+cfg_if::cfg_if! {
+    if #[cfg(feature = "precision")] {
+        pub type Int = i64;
+        pub type Float = f64;
+
+        const FLOAT_TYPE: &str = "f64";
+        const INT_TYPE: &str = "i64";
+    } else {
+        pub type Int = i32;
+        pub type Float = f32;
+
+        const FLOAT_TYPE: &str = "f32";
+        const INT_TYPE: &str = "i32";
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Value {
+    Float(Float),
+    Int(Int),
+    String(String),
+    Bool(bool),
+    Group(Group),
+}
+
+impl From<Group> for Value {
+    fn from(group: Group) -> Self {
+        Value::Group(group)
+    }
+}
+
+impl From<String> for Value {
+    fn from(string: String) -> Self {
+        Value::String(string)
+    }
+}
+
+impl From<&str> for Value {
+    fn from(string: &str) -> Self {
+        Value::String(string.to_string())
+    }
+}
+
+macro_rules! impl_value_as_type {
+    ($variant:ident, $typ:ty, $typ_name:expr, false) => {
+        impl<'a> TryFrom<&'a Value> for &'a $typ {
+            type Error = Error;
+
+            fn try_from(value: &'a Value) -> Result<Self> {
+                match value {
+                    Value::$variant(v) => Ok(v),
+                    _ => Err(Error::InvalidConversion {
+                        variant: stringify!($variant),
+                        output_type: $typ_name,
+                    }),
+                }
+            }
+        }
+
+        impl<'a> TryFrom<&'a mut Value> for &'a mut $typ {
+            type Error = Error;
+
+            fn try_from(value: &'a mut Value) -> Result<Self> {
+                match value {
+                    Value::$variant(v) => Ok(v),
+                    _ => Err(Error::InvalidConversion {
+                        variant: stringify!($variant),
+                        output_type: $typ_name,
+                    }),
+                }
+            }
+        }
+    };
+
+    ($variant:ident, $typ:ty, $typ_name:expr, true) => {
+        impl_value_as_type!($variant, $typ, $typ_name, false);
+
+        impl<'a> TryFrom<&'a mut Value> for $typ {
+            type Error = Error;
+
+            fn try_from(value: &'a mut Value) -> Result<Self> {
+                match value {
+                    Value::$variant(v) => Ok(*v),
+                    _ => Err(Error::InvalidConversion {
+                        variant: stringify!($variant),
+                        output_type: $typ_name,
+                    }),
+                }
+            }
+        }
+    };
+}
+
+impl_value_as_type!(Float, Float, FLOAT_TYPE, true);
+impl_value_as_type!(Int, Int, INT_TYPE, true);
+impl_value_as_type!(Bool, bool, "bool", true);
+impl_value_as_type!(String, String, "String", false);
+impl_value_as_type!(String, str, "str", false);
+impl_value_as_type!(Group, Group, "Group", false);
+
+#[derive(Debug, Clone)]
+pub struct Entry {
+    pub name: String,
+    pub value: Value,
+}
+
+#[derive(Debug, Clone)]
+pub struct Group {
+    pub entries: Vec<Entry>,
+}
+
+pub trait Accessor {
+    fn get(&self, key: &[&str]) -> Option<&Value>;
+    fn get_mut(&mut self, key: &[&str]) -> Option<&mut Value>;
+    fn get_all(&self, key: &[&str]) -> Vec<&Value>;
+    fn get_all_mut(&mut self, key: &[&str]) -> Vec<&mut Value>;
+}
+
+impl Accessor for Group {
+    fn get(&self, key: &[&str]) -> Option<&Value> {
+        if key.is_empty() {
+            return None;
+        }
+
+        let entry = self.entries.iter().find(|e| e.name == key[0])?;
+        let remaining_keys = &key[1..];
+
+        if remaining_keys.is_empty() {
+            Some(&entry.value)
+        } else {
+            match &entry.value {
+                Value::Group(group) => group.get(remaining_keys),
+                _ => None,
+            }
+        }
+    }
+
+    fn get_mut(&mut self, key: &[&str]) -> Option<&mut Value> {
+        if key.is_empty() {
+            return None;
+        }
+
+        let entry = self.entries.iter_mut().find(|e| e.name == key[0])?;
+        let remaining_keys = &key[1..];
+
+        if remaining_keys.is_empty() {
+            Some(&mut entry.value)
+        } else {
+            match &mut entry.value {
+                Value::Group(group) => group.get_mut(remaining_keys),
+                _ => None,
+            }
+        }
+    }
+
+    fn get_all(&self, key: &[&str]) -> Vec<&Value> {
+        let mut v = vec![];
+
+        let entries = self.entries.iter().filter(|e| e.name == key[0]);
+        let remaining_keys = &key[1..];
+
+        for entry in entries {
+            if remaining_keys.is_empty() {
+                v.push(&entry.value);
+            } else {
+                match &entry.value {
+                    Value::Group(group) => v.extend(group.get_all(remaining_keys)),
+                    _ => {}
+                }
+            }
+        }
+
+        v
+    }
+
+    fn get_all_mut(&mut self, key: &[&str]) -> Vec<&mut Value> {
+        let mut v = vec![];
+
+        let entries = self.entries.iter_mut().filter(|e| e.name == key[0]);
+        let remaining_keys = &key[1..];
+
+        for entry in entries {
+            if remaining_keys.is_empty() {
+                v.push(&mut entry.value);
+            } else {
+                match &mut entry.value {
+                    Value::Group(group) => v.extend(group.get_all_mut(remaining_keys)),
+                    _ => {}
+                }
+            }
+        }
+
+        v
+    }
+}
+
+#[test]
+fn test() {
+    let mut group = Group {
+        entries: vec![Entry {
+            name: "key".to_string(),
+            value: Group {
+                entries: vec![Entry {
+                    name: "key".into(),
+                    value: "hello".into(),
+                }],
+            }
+            .into(),
+        }],
+    };
+
+    let value: &str = group.get(&["key", "key"]).unwrap().try_into().unwrap();
+    println!("{value:?}");
+}