use indexmap::IndexMap;
#[cfg(feature = "serialization")]
use serde::{Deserialize, Serialize};
pub mod parse_ctx;
pub mod parser;
pub mod system;
pub mod transform;
pub(crate) mod utils;
pub mod vmf;
pub mod errors;
pub mod prelude;
pub use errors::{VmfError, VmfResult};
pub use parse_ctx::{FromBlock, ParseCtx};
pub trait VmfSerializable {
fn to_vmf_string(&self, indent_level: usize) -> String;
}
pub use system::{Flattened, Instance, VmfSystem};
pub use transform::Transform;
pub use vmf::{EntId, EntityIndex, VmfFile};
#[derive(Debug, Default, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
pub struct Extras {
pub key_values: IndexMap<String, String>,
pub blocks: Vec<VmfBlock>,
}
pub const REPEATED_KEY_SEP: char = '\r';
pub fn write_key_value(output: &mut String, indent: &str, key: &str, value: &str) {
for part in value.split(REPEATED_KEY_SEP) {
output.push_str(indent);
output.push('"');
output.push_str(key);
output.push_str("\" \"");
output.push_str(part);
output.push_str("\"\n");
}
}
pub fn join_repeated_key(values: impl IntoIterator<Item = impl std::fmt::Display>) -> String {
let mut joined = String::new();
for value in values {
if !joined.is_empty() {
joined.push(REPEATED_KEY_SEP);
}
joined.push_str(&value.to_string());
}
joined
}
impl Extras {
pub fn is_empty(&self) -> bool {
self.key_values.is_empty() && self.blocks.is_empty()
}
pub fn write_key_values(&self, output: &mut String, indent_level: usize) {
let indent = "\t".repeat(indent_level);
for (key, value) in &self.key_values {
write_key_value(output, &indent, key, value);
}
}
pub fn write_blocks(&self, output: &mut String, indent_level: usize) {
for block in &self.blocks {
output.push_str(&block.serialize(indent_level));
}
}
}
#[derive(Debug, Default, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
pub struct VmfBlock {
pub name: String,
pub key_values: IndexMap<String, String>, pub blocks: Vec<VmfBlock>,
}
impl VmfBlock {
pub fn serialize(&self, indent_level: usize) -> String {
let indent = "\t".repeat(indent_level);
let mut output = String::new();
output.push_str(&format!("{}{}\n", indent, self.name));
output.push_str(&format!("{}{{\n", indent));
for (key, value) in &self.key_values {
write_key_value(&mut output, &format!("{indent}\t"), key, value);
}
for block in &self.blocks {
output.push_str(&block.serialize(indent_level + 1));
}
output.push_str(&format!("{}}}\n", indent));
output
}
}