ltk_meta 0.5.1

Metadata formats and utilities for League Toolkit
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

use super::BinObject;
use crate::Bin;

/// A builder for constructing [`Bin`] instances.
///
/// # Examples
///
/// ```
/// use ltk_meta::{Bin, BinObject, property::NoMeta};
///
/// let tree = Bin::<NoMeta>::builder()
///     .is_override(false)
///     .dependency("base.bin")
///     .dependencies(["extra1.bin", "extra2.bin"])
///     .object(BinObject::new(0x1234, 0x5678))
///     .build();
/// ```
#[derive(Debug, Default, Clone)]
pub struct Builder<M> {
    is_override: bool,
    objects: Vec<BinObject<M>>,
    dependencies: Vec<String>,
}

impl<M> Builder<M> {
    /// See: [`Bin::builder`]
    pub fn new() -> Self
    where
        M: Default,
    {
        Self::default()
    }

    /// Sets whether this is an override bin file.
    ///
    /// Default is `false`.
    pub fn is_override(mut self, is_override: bool) -> Self {
        self.is_override = is_override;
        self
    }

    /// Adds a single dependency.
    pub fn dependency(mut self, dep: impl Into<String>) -> Self {
        self.dependencies.push(dep.into());
        self
    }

    /// Adds multiple dependencies.
    pub fn dependencies(mut self, deps: impl IntoIterator<Item = impl Into<String>>) -> Self {
        self.dependencies.extend(deps.into_iter().map(Into::into));
        self
    }

    /// Adds a single object.
    pub fn object(mut self, obj: BinObject<M>) -> Self {
        self.objects.push(obj);
        self
    }

    /// Adds multiple objects.
    pub fn objects(mut self, objs: impl IntoIterator<Item = BinObject<M>>) -> Self {
        self.objects.extend(objs);
        self
    }

    /// Build the final [`Bin`].
    ///
    /// The resulting tree will have version 3, which is always used when writing.
    pub fn build(self) -> Bin<M> {
        Bin {
            version: 3,
            is_override: self.is_override,
            objects: self.objects.into_iter().map(|o| (o.path_hash, o)).collect(),
            dependencies: self.dependencies,
            data_overrides: Vec::new(),
        }
    }
}