Struct ResourceLocation 

pub struct ResourceLocation {
    pub is_tag: bool,
    pub namespace: Option<String>,
    pub paths: NonEmpty<String>,
}

Fields

is_tag: bool

namespace: Option<String>

paths: NonEmpty<String>

Implementations

impl ResourceLocation

pub fn new<T: ToString>( is_tag: bool, namespace: Option<T>, paths: NonEmpty<T>, ) -> Self

pub fn new_namespace_paths<T: ToString>( namespace: T, paths: NonEmpty<T>, ) -> Self

pub fn new_namespace_path<T: ToString>(namespace: T, path: T) -> Self

Examples found in repository

examples/datapack.rs (lines 48-51)

fn main() {
    use std::collections::BTreeMap;
    use std::path::Path;

    let pack_meta = PackMCMeta {
        pack: Pack {
            description: serde_json::json!("A datapack written with Rust!"),
            pack_format: Some(15),
            supported_formats: Some(Format::Array(15, 20)),
            min_format: None,
            max_format: None,
        },
        features: None,
        filter: None,
        overlays: None,
        language: None,
    };

    let mut my_namespace = Namespace::default();

    my_namespace.functions.push(FilePathNode::File(
        "main".to_string(),
        "say Datapack loaded!".to_string(),
    ));

    my_namespace.functions.push(FilePathNode::Directory(
        "utils".to_string(),
        vec![FilePathNode::File(
            "teleport".to_string(),
            "tp @s ~ ~10 ~".to_string(),
        )],
    ));

    let mut block_tags = BTreeMap::new();
    block_tags.insert(
        TagType::Block,
        vec![FilePathNode::File(
            "cool_blocks".to_string(),
            Tag {
                replace: Some(false),
                values: vec![
                    TagValue::ResourceLocation(ResourceLocation::new_namespace_path(
                        "minecraft",
                        "diamond_block",
                    )),
                    TagValue::ResourceLocation(ResourceLocation::new_namespace_path(
                        "minecraft",
                        "emerald_block",
                    )),
                ],
            },
        )],
    );
    my_namespace.tags = block_tags;

    let mut namespaces = BTreeMap::new();
    namespaces.insert("mydp".to_string(), my_namespace);

    let my_datapack = Datapack {
        pack: pack_meta,
        namespaces,
    };

    let output_path = Path::new("my_awesome_datapack");
    if let Err(e) = my_datapack.write(output_path) {
        eprintln!("Failed to write datapack: {}", e);
    }
}

pub fn new_paths<T: ToString>(paths: NonEmpty<T>) -> Self

pub fn new_path<T: ToString>(path: T) -> Self

pub fn paths_string(&self) -> String

Trait Implementations

impl Clone for ResourceLocation

fn clone(&self) -> ResourceLocation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ResourceLocation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResourceLocation

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ResourceLocation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for ResourceLocation

type Err = ResourceLocationParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl HasMacro for ResourceLocation

fn has_macro(&self) -> bool

fn has_macro_conflict(&self) -> bool

impl Hash for ResourceLocation

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ResourceLocation

fn cmp(&self, other: &ResourceLocation) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ResourceLocation

fn eq(&self, other: &ResourceLocation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for ResourceLocation

fn partial_cmp(&self, other: &ResourceLocation) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ResourceLocation

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ResourceLocation

impl StructuralPartialEq for ResourceLocation